The following plugin provides functionality available through Pipeline-compatible steps. Read more about how to integrate steps into your Pipeline in the Steps section of the Pipeline Syntax page.

For a list of other such plugins, see the Pipeline Steps Reference page.

Pipeline: Multibranch

properties: Set job properties

Updates the properties of the job which runs this step. Mainly useful from multibranch Pipelines, so that Jenkinsfile itself can encode what would otherwise be static job configuration. Existing properties set through the Jenkins UI for non-multibranch Pipelines will be preserved.
  • properties
      Array / List of Nested Choice of Objects
    • allowBrokenBuildClaiming
      • $class: 'AssemblaProjectProperty'
        • spaceName : String
          Insert the Assembla Space name for this project
        • backtrackEnabled : boolean
          Check to allow Jenkins to post a comment to Assembla with the build number which integrates the given ticket.
        • siteName : String
        • pluginEnabled : boolean
      • $class: 'AuthorizeProjectProperty'
        Run builds with specified authorization. Authorization of builds defaults to SYSTEM privilege. You can restrict builds to access other projects in Jenkins by specifying authorization when plugins perform access check properly.
        • strategy
            Nested Choice of Objects
          • $class: 'AnonymousAuthorizationStrategy'
            Run a build as an anonymous user.
            • $class: 'OwnershipAuthorizeProjectStrategy'
              This strategy authenticates as a job's owner if it is specified. Otherwise, the anonymous credentials will be used.
              • $class: 'SpecificUsersAuthorizationStrategy'
                Run a build as a specified user. You are required to one of following condition to successfully save the configuration.
                • You are an administrator.
                • You yourself are the specified user.
                • The specified user is not changed from the last configuration, and "No need for re-authentication" was checked in the last configuration.
                • You enter the password for the specified user.
                • userid : String
                  ID of the user to run builds as.
                • useApitoken : boolean
                • apitoken : String
                • password : String
                  Password of the user specified in User ID. This field is shown only when authentication is required for this user.

                  You can use API token for authentication instead by checking "Use API Token for authentication". You can get your API token from your user configuration page.

                • dontRestrictJobConfiguration : boolean (optional)

                  "Run as Specific User" restricts the job configuration only to the specified user. Other users cannot configure the job even if the Jenkins access control configuration allows it.

                  This option disabled that feature, and the job configuration is controlled by the Jenkins access control.

                  Use this feature carefully, for a malicious user can run unintended commands without authentication by changing configuration of the job. Check the access control configuration, and ensure that the CONFIGURE permission for this job is granted only to proper users.

              • $class: 'SystemAuthorizationStrategy'
                Run a build as the SYSTEM user.
                • $class: 'TriggeringUsersAuthorizationStrategy'
                  Run a build as a user who triggered it. If the build was triggered as a downstream build, the build runs as a user who triggered the upstream build. This does not work when the build is triggered by SCM polling or scheduled triggering. The build runs as SYSTEM authorization in those cases.
              • azureAdAuthorizationMatrix
                • entries
                    Array / List of Nested Choice of Objects
                  • group
                    • name : String
                    • permissions : Array / List of String
                    • user
                      • name : String
                      • permissions : Array / List of String
                      • userOrGroup
                        • name : String
                        • permissions : Array / List of String
                      • inheritanceStrategy (optional)
                          Nested Choice of Objects
                        • inheritingGlobal
                          • inheriting
                            • nonInheriting
                          • $class: 'BacklogProjectProperty'
                            • url : String
                              Set the space URL or project URL of Backlog used with this project. Samples of URL are shown below.
                              • https://demo.backlog.jp/
                              • https://demo.backlog.jp/projects/DORA
                            • userId : String

                              UserId when using Backlog API.

                            • password : String

                              Password when using Backlog API.

                            • apiKey : String

                              API key when using Backlog API version 2.

                          • $class: 'BalanceProjectProperty'
                            • disk : long (optional)
                              The default unit is G.
                            • diskUnit (optional)
                              • Values: K, M, G
                            • memory : long (optional)
                              The default unit is M.
                            • memoryUnit (optional)
                              • Values: K, M, G
                          • $class: 'BeforeJobSnapshotJobProperty'
                            • snapshots
                                Nested Object
                              • snapshotsEnabled : boolean
                              • snapshotName : String
                          • $class: 'BlockBuildJobProperty'
                            • useBlockBuildUpstreamProject : boolean

                              When this option is checked, Jenkins will prevent the project from building when a dependency of this project is in the queue, or building. The dependencies include the direct as well as the transitive dependencies.

                              Optional final projects can be given. When Jenkins checks for dependencies to block the build, it will stop checking when it reaches the final projects.

                            • finalUpstreamProjects : String

                              Comma separated list of upstream projects.

                            • useBlockBuildDownstreamProject : boolean

                              When this option is checked, Jenkins will prevent the project from building when a dependency of this project is in the queue, or building. The dependencies include the direct as well as the transitive dependencies.

                              Optional final projects can be given. When Jenkins checks for dependencies to block the build, it will stop checking when it reaches the final projects.

                            • finalDownstreamProjects : String

                              Comma separated list of downstream projects.

                          • $class: 'BlockItemJobProperty'
                            Allows block/unblock item (job) in queue. Affects only job where this property enabled.
                            • conditions
                              Conditions for blocking/unblocking. First matched condition wins (waterfall).
                                Array / List of Nested Choice of Objects
                              • $class: 'BuildingBlockQueueCondition'
                                Blocks this job when last run of specified job is building.
                                • project : String
                                  If the name starts from '/', like "/foo/bar/zot", then it's interpreted as absolute. Otherwise, the name should be something like "foo/bar" and it's interpreted like relative path name in the file system is, against the given context.

                                  For compatibility, as a fallback when nothing else matches, a simple path like "foo/bar" can also be treated as "/foo/bar".

                              • unblockGitHubPRLabel
                                • label
                                    Nested Object
                                    Help page for GitHubPRLabel class. Not used anywhere?
                                  • labels : String

                                    Every new label on new line

                              • $class: 'JobResultBlockQueueCondition'
                                Blocks this job when last run of specified job matches result.
                                • project : String
                                  If the name starts from '/', like "/foo/bar/zot", then it's interpreted as absolute. Otherwise, the name should be something like "foo/bar" and it's interpreted like relative path name in the file system is, against the given context.

                                  For compatibility, as a fallback when nothing else matches, a simple path like "foo/bar" can also be treated as "/foo/bar".

                                • result : String
                          • buildBlocker
                            • useBuildBlocker : boolean
                            • blockLevel : String
                            • scanQueueFor : String
                            • blockingJobs : String
                              Insert one regular expression per line to select blocking jobs by their names. E.g.:
                                .*-deploy
                                ^maintainance.*
                                
                          • $class: 'BuildConfigProjectProperty'
                            • namespace : String
                            • name : String
                            • uid : String
                            • resourceVersion : String
                            • buildRunPolicy : String
                          • buildDiscarder
                            This determines when, if ever, build records for this project should be discarded. Build records include the console output, archived artifacts, and any other metadata related to a particular build.

                            Keeping fewer builds means less disk space will be used in the Build Record Root Directory , which is specified on the Configure System screen.

                            Jenkins offers two options for determining when builds should be discarded:

                            1. Build age: discard builds when they reach a certain age; for example, seven days old.
                            2. Build count: discard the oldest build when a certain number of builds already exist.
                            These two options can be active at the same time, so you can keep builds for 14 days, but only up to a limit of 50 builds, for example. If either limit is exceeded, then any builds beyond that limit will be discarded.

                            You can also ensure that important builds are kept forever, regardless of the setting here — click the Keep this build forever button on the build page.
                            The last stable and last successful build are also excluded from these rules.

                            In the Advanced section, the same options can be specified, but specifically for build artifacts . If enabled, build artifacts will be discarded for any builds which exceed the defined limits. The builds themselves will still be kept; only the associated artifacts, if any, will be deleted.

                            For example, if a project builds some software and produces a large installer, which is archived, you may wish to always keep the console log and information about which source control commit was built, while for disk space reasons, you may want to keep only the last three installers that were built.
                            This can make sense for projects where you can easily recreate the same artifacts later by building the same source control commit again.

                            Note that Jenkins does not discard items immediately when this configuration is updated, or as soon as any of the configured values are exceeded; these rules are evaluated each time a build of this project completes.
                            • strategy
                                Nested Choice of Objects
                              • BuildHistoryManager
                                • rules
                                    Array / List of Nested Object
                                  • conditions
                                      Array / List of Nested Choice of Objects
                                    • BuildAgeRange

                                      Description

                                      Matches builds that age is between given days range. It calculates days only without checking build time.

                                      Use cases

                                      Allow to match several builds at once based on build age.

                                      Warning!

                                      Provided values are always relative to today so most likely they interact with different builds every day.
                                      Time of the build completed is reset to zero before comparison so only days are compared.

                                      maxDaysAge = 0 refers to builds which were completed today
                                      1-2 means builds which were completed yesterday or the day before yesterday.
                                      Check also Wiki.

                                      Build completed time (age) is calculated as sum of getStartTimeInMillis() and getDuration().

                                      • maxDaysAge : int (optional)
                                      • minDaysAge : int (optional)
                                    • BuildDescription

                                      Description

                                      Matches builds that description is equal, contains or matches given pattern.

                                      Use cases

                                      Helpful when build description contains text that can be used for decision what to do with the build.

                                      Warning!

                                      Leaving pattern field empty makes this condition valid for all builds that have undefined or empty build what is default value for new created builds.

                                      Methods equals and contains expect to have plain text pattern. To define proper regular expression pattern for matching type follow the guideline.

                                      • matchingMethod : String (optional)
                                      • pattern : String (optional)
                                    • BuildNumberRange

                                      Description

                                      Matches builds with build number between given number range (both inclusive).

                                      Use cases

                                      Allow to match several builds at once based on build numbers that do not change over the time.
                                      Check also Wiki.

                                      Warning!

                                      Use number 1 to match very build from the beginning of the history.

                                      • maxBuildNumber : int (optional)
                                      • minBuildNumber : int (optional)
                                    • BuildResult

                                      Description

                                      Matches builds with chosen results.

                                      Use cases

                                      Allow to select builds based on the result.
                                      Check also Wiki.

                                      • matchAborted : boolean (optional)
                                      • matchFailure : boolean (optional)
                                      • matchNotBuilt : boolean (optional)
                                      • matchSuccess : boolean (optional)
                                      • matchUnstable : boolean (optional)
                                    • Cause

                                      Description

                                      Matches builds that class for the cause contains given string.

                                      Use cases

                                      Most popular class names are:

                                      To check class name of the cause, use following code for debug:

                                      stage("Print causes") {
                                          for (String cause in currentBuild.getBuildCauses()) {
                                              print cause._class
                                          }
                                      }
                                      

                                      Warning!

                                      It validates every cause of the build and expects that at least one of cause matches.
                                      Does not support regular expressions but uses contains() to compare class name.

                                      • causeClass : String (optional)
                                    • MatchEveryBuild

                                      Description

                                      Matches every build. Unconditionally.

                                      Use cases

                                      Allow to perform action for every build from the history.

                                      Warning!

                                      Use this action wisely because recovering deleted build might be impossible.

                                      • TokenMacro

                                        Description

                                        It consists from pair of template and value. Template written as token macro and is compared to value.

                                        Use cases

                                        Allow to build condition based on any variable which is provided by Token Macro Plugin.

                                        Warning!

                                        This plugin starts working then the build completes so it may not have access to all variables which are usually available during the build time.

                                        • template : String
                                        • value : String
                                    • actions
                                        Array / List of Nested Choice of Objects
                                      • ChangeBuildDescription

                                        Description

                                        Updates build description.

                                        Use cases

                                        This action is helpful for testing and debugging. It does not change or delete the build what might be hard to rollback. Instead, it allows to test conditions before final action is used.

                                        The result of this action is a string [build-history-manager] which is prepend to job description.

                                        Use this action as long as the final result of condition is not examined. This is helpful also for users who do not have access to Jenkins logs.

                                        • DeleteArtifacts

                                          Description

                                          Deletes the build artifacts.

                                          Use cases

                                          Deletes the artifact when they it is not needed any more, it is not valuable or there is no need to keep all artifacts over the time.

                                          Check also Wiki.

                                          Warning!

                                          Use this action wisely because if wrong build is matched to this action then recovering deleted build might be impossible.

                                          • DeleteBuild

                                            Description

                                            Deletes the build.

                                            Use cases

                                            Deletes the build from the history when it is not needed any more, it is not valuable or there is no need to keep all builds over the time.

                                            Warning!

                                            Use this action wisely because if wrong build is matched to this action then recovering deleted build might be impossible.

                                            • DeleteLogFile

                                              Description

                                              Deletes the build log file.

                                              Use cases

                                              To leave build and delete the log file which eg. might contain sensitive data or are very big.

                                              Warning!

                                              Log file should not be deleted for the build which was already removed.

                                            • continueAfterMatch : boolean (optional)

                                              Description

                                              • When this flag is set to false, AND the conditions of this rule are met, this rule will be the final rule applied to the build, the plugin stops applying rules to this build, and goes to the next iteration of the "for each completed build" loop.
                                              • When this flag is set to true (which is the default), AND the conditions of this rule are met, the next rule is applied to the same build, and goes to the next iteration of the "for each rule" loop.

                                              Use cases

                                              This feature allows for the application of multiple consecutive rules to the same build, as long as the conditions for each of those rules are met.

                                            • matchAtMost : int (optional)

                                              Description

                                              The rule will stop being processed after a certain number of matched builds. Once this condition is met, only the other rules will continue to be processed.

                                              Use cases

                                              This feature provides the option to control the number of builds the rule can process. It may save a significant amount of time when the build history is long.

                                              • If the value is set to -1, there is no limitation, all builds will be evaluated.
                                              • If the value is set to 0, no builds will be evaluated. This disables the rule as it will not apply to any build.
                                              • If the value is set to 1..n, once the value is reached, the rule is effectively disabled and is no longer applied.

                                              Warning!

                                              If the matchAtMost value is set to zero, the rule is effectively disabled. This is useful if the user wants to disable a rule while keeping its other configuration values.

                                        • $class: 'BuildRotator'
                                          • daysToKeep : int
                                          • numToKeep : int
                                          • artifactsDaysToKeep : int
                                          • artifactsNumToKeep : int
                                        • $class: 'EnhancedOldBuildDiscarder'
                                          • daysToKeepStr : String
                                          • numToKeepStr : String
                                          • artifactDaysToKeepStr : String
                                          • artifactNumToKeepStr : String
                                          • discardOnlyOnSuccess : boolean
                                          • holdMaxBuilds : boolean
                                            Allows a user to request both quantity and age conditions be met prior to build discard. This means that if N max builds are set with M max age, builds will only be cleared if they exceed the given age and if their quantity exceed the N max build quantity. The feature will thus never allow build deletion to leave less builds than the N max builds set, or allow build deletion of builds under the M max age regardless of N max builds set. NOTE: This feature does nothing if Days to keep builds and/or Max # of builds to keep are empty. Setting Days to keep builds to 0 causes all builds to be seen as beyond the age limit. Setting Max # of builds to keep to 0 causes any build exceeding the age limit to be discarded.
                                        • logRotator
                                          • daysToKeepStr : String
                                          • numToKeepStr : String
                                          • artifactDaysToKeepStr : String
                                          • artifactNumToKeepStr : String
                                    • compressBuildLog
                                      • customizeBuildNow
                                        • labels
                                            Nested Object
                                          • alternateBuildButton : String (optional)
                                            Normally on the page where you enter the parameters of a job the button is labeled "Build" but sometimes it's helpful to use the right phrase for the job like "Deploy" or "Run". This field allows you to provide whatever text makes sense for executing the job. Leave empty to use the globally configured value.
                                          • alternateBuildNow : String (optional)
                                            Normally to execute a job in jenkins the common phrase used throughout is "Build Now" but sometimes it's helpful to use the right phrase for the job like "Deploy" or "Execute" or "Promote". This field allows you to provide whatever text makes sense for executing the job. Leave empty to use the globally configured value.
                                          • alternateBuildWithParams : String (optional)
                                            Normally to execute a job with parameters in jenkins the common phrase used throughout is "Build with Parameters" but sometimes it's helpful to use the right phrase for the job like "Deploy with Parameters" or "Run with Parameters". This field allows you to provide whatever text makes sense for executing when the job has parameters. Leave empty to use the globally configured value.
                                      • $class: 'BuildPreferenceJobProperty'
                                        Defines which nodes this project prefers to run on. This works when "Scoring by Node Preferences" are registered as a Scoring Rule.
                                        • buildPreferenceList
                                          Define target nodes and their scores. If nodes are targeted by multiple preferences, scores are accumulated.
                                            Array / List of Nested Object
                                          • labelExpression : String
                                            Expression to specify nodes to apply the score. Can be node name, node labels or conjunctions of them with logical operators See help for "Label Expression" of "Restrict where this project can be run"
                                          • preference : int
                                            A score added for the target nodes. Higher score results the nodes preferred. This can be a value less than 0.
                                      • $class: 'CNAuthProjectProperty'
                                        • project : String

                                          This CollabNet TeamForge project will be used to determine what permissions users have on this Jenkins job.

                                        • createRoles : boolean

                                          Check "Create Jenkins roles" to automatically create the Jenkins-related roles in the CollabNet TeamForge project. This will only work if you are a project admin in the project. If the roles already exist, no new roles will be created.

                                        • storedProjectId : String
                                        • grantDefaultRoles : boolean

                                          Check "Grant Default Permissions" to automatically give project admins in the project full permissions in the project, and all members read permission. This will only work if you are a project admin in the project.

                                      • $class: 'CachetJobProperty'
                                        • requiredResources : boolean
                                        • resources : Array / List of String
                                        • $class: 'ChaosButlerOptOutJobProperty'
                                          • optOut : boolean
                                            The Chaos Butler periodically wakes up and selects a build agent at random for disconnection. When this opt-out is selected, the Chaos Butler will ensure that the selected build agent is not running this job. In other words, enable the opt-out if you have a job that is critical and not resilient enough for use with the Chaos Butler.
                                        • $class: 'CheckBuildJobProperty'
                                          • checkPars : String
                                            Enter the parameters you want to check, separated by comma. Leave it empty to check all the parameters.
                                          • on : boolean
                                        • $class: 'ConfigurationPermissionEnforcer'
                                          • $class: 'ConjurJITJobProperty'
                                            • conjurConfiguration (optional)
                                                Nested Object
                                              • applianceURL : String (optional)
                                              • account : String (optional)
                                              • certificateCredentialID : String (optional)
                                              • credentialID : String (optional)
                                            • authWebServiceId : String (optional)
                                            • hostPrefix : String (optional)
                                            • inheritFromParent : boolean (optional)
                                            • useJustInTime : boolean (optional)
                                          • $class: 'ContrastPluginConfig'
                                            • copyArtifactPermission
                                              Define projects that can copy artifacts of this project without authentication.
                                              • projectNames : String
                                                Comma-separated list of projects that can copy artifacts of this project. Wildcard character ('*') is allowed.

                                                Both relative names (../OtherFolder/ProjectName) and absolute names (/Folder/ProjectName) are allowed. Note that you need to add "/" to the head of the name to specify it as an absolute name.

                                            • $class: 'CustomIconProperty'
                                              • iconfile : String
                                                Select an icon to represent the job.
                                            • $class: 'CustomMsgJobProperty'
                                              • on : boolean
                                              • briefDesc : String
                                              • insertOnFinish : boolean
                                            • $class: 'DatadogJobProperty'
                                              • emitSCMEvents : boolean (optional)
                                              • enableFile : boolean (optional)
                                              • enableProperty : boolean (optional)
                                              • tagFile : String (optional)
                                              • tagProperties : String (optional)
                                            • $class: 'DeployNowJobProperty'
                                              • oneClickDeploy : boolean
                                              • hosts
                                                • Type: ? extends com.cloudbees.plugins.deployer.hosts.DeployHost<?, ?>
                                            • $class: 'DingTalkJobProperty'
                                              • notifierConfigs
                                                  Array / List of Nested Object
                                                • raw : boolean
                                                  Disabling the plugin's built-in encapsulation message, only sends the Custom Message below, which is equivalent to fully customizing the message using markdown.
                                                • disabled : boolean
                                                • checked : boolean
                                                • robotId : String
                                                • robotName : String
                                                • atAll : boolean
                                                • atMobile : String
                                                • content : String
                                                  To append message content, please use Markdown format.

                                                  Supported Environment Variables:
                                                  • Jenkins Built-in Environment Variables
                                                  • Environment Variables Description
                                                    EXECUTOR_NAME Executor name
                                                    EXECUTOR_MOBILE Executor mobile
                                                    PROJECT_NAME Project name
                                                    PROJECT_URL Project url
                                                    JOB_NAME Job name
                                                    JOB_URL Job url
                                                    JOB_DURATION Job duration
                                                    JOB_STATUS Job status
                                                • message : String
                                                  To append message content, please use Markdown format.

                                                  Supported Environment Variables:
                                                  • Jenkins Built-in Environment Variables
                                                  • Environment Variables Description
                                                    EXECUTOR_NAME Executor name
                                                    EXECUTOR_MOBILE Executor mobile
                                                    PROJECT_NAME Project name
                                                    PROJECT_URL Project url
                                                    JOB_NAME Job name
                                                    JOB_URL Job url
                                                    JOB_DURATION Job duration
                                                    JOB_STATUS Job status
                                                • noticeOccasions : Array / List of String
                                              • disableConcurrentBuilds
                                                • abortPrevious : boolean (optional)
                                                  By default, disabling concurrent builds means that new builds will queue up and wait for a running build to complete. With this option, scheduling a new build immediately aborts any running build. This is handy for example if you have an expensive pull request testing procedure and do not wish to waste any time completing tests on an outdated commit.
                                              • disableResume
                                                • $class: 'DockerJobProperty'
                                                  When a job completes, the docker agent instance is committed with repository based on the job name and build number as tag
                                                  • additionalTag : String
                                                  • cleanImages : boolean
                                                  • registry (optional)
                                                      Nested Object
                                                    • url : String
                                                      URL to the Docker registry you are using. May be left blank to use the public DockerHub registry (currently https://index.docker.io/v1/).
                                                    • credentialsId : String
                                                • $class: 'DockerJobTemplateProperty'
                                                  • cloudname : String
                                                    Specify one of the Docker Clouds defined under global configuration.
                                                  • template
                                                      Nested Object
                                                    • dockerTemplateBase
                                                        Nested Choice of Objects
                                                      • $class: 'DockerTemplateBase'
                                                        • image : String
                                                          The hash or tagged name of the image that you wish docker to run (e.g "docker run -i -t <id> /bin/bash")
                                                        • bindAllPorts : boolean (optional)
                                                        • bindPorts : String (optional)
                                                          Bind ports from inside the container to outside of the host, scheme is hostport:containerport. Same effect as the "-p" or "-P" option on the CLI. Docker documentation
                                                        • capabilitiesToAddString : String (optional)

                                                          A list of new line separated capabilities.

                                                          Each line represents an option for the --cap-add parameter sent to the docker server. Each one must be a known capability "Key" as per the docker documentation.

                                                          Please check https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities for further information.

                                                        • capabilitiesToDropString : String (optional)

                                                          A list of new line separated capabilities.

                                                          Each line represents an option for the --cap-drop parameter sent to the docker server. Each one must be a known capability "Key" as per the docker documentation.

                                                          Please check https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities for further information.

                                                        • cgroupParent : String (optional)

                                                          This allows agents to run in a cgroup other than the daemon/system default.

                                                          Please check https://docs.docker.com/reference/cli/docker/container/run/#cgroup-parent for further information.

                                                        • cpuPeriod : long (optional)

                                                          Set the period of CPUs to limit the container’s CPU usage.

                                                          The default CPU CFS (Completely Fair Scheduler) period is 100000us.

                                                          Consult Docker Run Documentation for further information.

                                                        • cpuQuota : long (optional)

                                                          Limits the container’s CPU usage.

                                                          The default 0 value allows the container to take 100% of a CPU resource.

                                                          Consult Docker Run Documentation for further information.

                                                        • cpuShares : int (optional)
                                                          Similarly the operator can increase the priority of this container. By default (no value), all containers run at the same priority and get the same proportion of CPU cycles, but you can tell the kernel to give more shares of CPU time to one or more containers when you start them via Docker.

                                                          Consult Docker Run Documentation for further information.
                                                        • cpus : String (optional)

                                                          Specify how much of the available CPU resources a container can use as a floating point number.

                                                          The default is not set.

                                                          Consult Docker Run Documentation for further information.

                                                        • devicesString : String (optional)
                                                          New line separated list of devices to be mapped (e.g: /dev/fuse). The full scheme is origin:destination:permissions, although just specifying the origin is enough. Docker documentation
                                                        • dnsString : String (optional)
                                                          Set the DNS servers to use within your images, if not set Docker will use DNS settings of the host
                                                        • dockerCommand : String (optional)
                                                          Specifies a command to be executed upon containter start. Note this setting might have impact on the Launch mechanism, for example SSH Launcher do configure sshd with injected keys authentication, overriding this command might prevent the agent to start. Please refer to docker documentation for more details.
                                                          Supplied command must keep the container running, so Jenkins can establish a remote connection at any time. If not set, Jenkins will configure a general purpose command to just wait for stdin.
                                                          If you need your image to start some additional services, you should consider using an Entrypoint, and follow best practices so that the command is eventually executed by your entrypoint script.
                                                        • environmentsString : String (optional)

                                                          Zero or more environment variables that are set within the docker container. This is a multi-line text field. Each line must be of the form key=value and specify one variable name and its value.

                                                          Note that quotes are not interpreted.
                                                          e.g. foo="bar" will result in the quotes being part of foo's value.

                                                          Note also that whitespace is easily broken. Editing this field this without first expanding the box to its multi-line form will cause any whitespace within a line to be turned into end of line codes, breaking up the line and thus changing its meaning.
                                                          e.g. The single setting:
                                                           JENKINS_AGENT_SSH_PUBKEY=ssh-rsa MyPubKey jenkins@hostname
                                                          can be (accidentally) turned into three separate settings:
                                                           JENKINS_AGENT_SSH_PUBKEY=ssh-rsa MyPubKey jenkins@hostname
                                                          thus preventing the configuration from working as was intended.

                                                        • extraDockerLabelsString : String (optional)

                                                          A list of new line separated docker labels to be set on the container, Specified in the form "label_name=value".

                                                          This has no effect on Jenkins functionality, and is not related to the labels used by Jenkins to map jobs to agent nodes. These labels are metadata attached to the docker container itself (again, not the jenkins agent), and which can typically be read using the docker inspect command.

                                                          This can be useful when using a docker cluster (like docker swarm) to pass information to the scheduler, in conjunction with constraints; or to let other services (portainer, prometheus...) know how they should categorize or otherwise deal with this specific container.

                                                          Notes:

                                                          • spaces are the beginning and end of the label name and value will be removed
                                                          • invalid lines will be ignored
                                                        • extraGroupsString : String (optional)
                                                          Run a container with the specified additional groups (e.g. "docker run --group-add ...").
                                                          Refer to the docker run command reference for the correct syntax.
                                                        • extraHostsString : String (optional)
                                                          A list of new line separated hostnames/IP mappings to be added to the container’s /etc/hosts file. Specified in the form "hostname:IP".
                                                        • hostname : String (optional)
                                                        • macAddress : String (optional)
                                                          Container MAC address (e.g. 92:d0:c6:0a:29:33)
                                                        • memoryLimit : int (optional)

                                                          The operator can constrain the memory available to a container. If the host supports swap memory, then the setting can be larger than physical RAM.

                                                          When the processes inside the container exceed the memory limit, effects vary depending on your setup, e.g. out of memory errors may occur or the operating system could start killing processes.

                                                          Consult Docker Run Documentation for further information.

                                                          Note that on most Docker installations, the memory limit will not stop Jenkins/Docker from spawning so many containers that the machines total available memory will be exceeded. However, some Docker installations might be able to constrain the number of containers automatically using the memory limit.

                                                        • memorySwap : int (optional)
                                                          The operator can constrain the swap memory available to a container. This value is the total memory available to the container (swap + memory). To disable swap limit, you can set it to "-1".

                                                          Consult Docker Run Documentation for further information.
                                                        • mountsString : String (optional)
                                                          New line separated list of host mounts : type=volume|bind|tmpfs|npipe[,src|source=<some source>],dst|destination|target=<some target>[,<key>=<value>]*
                                                          See the official documentation
                                                        • network : String (optional)
                                                        • privileged : boolean (optional)
                                                        • pullCredentialsId : String (optional)
                                                        • securityOptsString : String (optional)

                                                          A list of new line separated security options.

                                                          Each line represents an option for the --security-opt parameter sent to the docker server. The options are in the format key=value.

                                                          Please check https://docs.docker.com/engine/reference/run/#security-configuration for further information.

                                                        • shmSize : int (optional)
                                                          Size of /dev/shm in MB. If you omit the size entirely (or use the value 0), the system uses 64 MB.

                                                          Consult Docker Run Documentation for further information.
                                                        • tty : boolean (optional)
                                                        • user : String (optional)
                                                          Run a container with the specified user (e.g. "docker run --user ...").
                                                          Refer to the docker run command reference for the correct syntax. Note that you have to specify a numeric uid if you want to run a container as a user, which exists on the host machine but does not exist within the container.
                                                        • volumesFromString : String (optional)
                                                          New line separated list of volumes to inherit from another container. Specified in the form <container name>[:<ro|rw>]
                                                          If accessmode not specified, then default rw will be used.
                                                          See the official documentation
                                                    • connector

                                                      For all connection methods, Jenkins will start by triggering a docker run. Then, after this step, there will optionally be more steps to establish the connection. There is currently three alternative ways to connect your Jenkins master to the dynamically provisioned Docker agents.

                                                      There are different pros and cons for each connection method. Depending on your environment, choose the one matching your needs. More detailed prerequisites are provided once you select a given method.

                                                      Attach Docker container
                                                      This method runs a container, then connects to it using docker exec, all by using the Docker API. The agent does not need to be able to reach the master through the network layers to communicate ; all will go through Docker API.
                                                      Connect with JNLP
                                                      The container will only be passed an initial docker run command with the right secret. And the remoting agent will establish the connection with the master through the network. Hence, the agent must be able to access the master through its address and port.
                                                      Connect with SSH
                                                      The specified image is expected to run an SSH server. Then, it will treat that computer like it usually does for any SSH connected agent: the master will log into it, copy the remoting agent, then start it.
                                                        Nested Choice of Objects
                                                      • attach
                                                        • entryPointCmdString : String (optional)
                                                        • javaExe : String (optional)
                                                        • jvmArgsString : String (optional)
                                                        • user : String (optional)
                                                          User that the Jenkins agent code will run as.
                                                          The container's default user (typically "root") will be used if this is left blank.
                                                      • jnlp
                                                        • entryPointArgumentsString : String (optional)
                                                        • jenkinsUrl : String (optional)
                                                          If needed, the Jenkins URL can be overwritten with this property (e.g. to support other HTTP(S) endpoints due to reverse proxies or firewalling). By default the URL from the global Jenkins configuration is used.
                                                        • user : String (optional)
                                                          User that the jenkins agent process will be run as. If not specified, the image's default user (typically "root").
                                                      • ssh
                                                        • sshKeyStrategy
                                                          Define how a SSH key pair is configured for ssh authentication in container.
                                                            Nested Choice of Objects
                                                          • $class: 'InjectSSHKey'
                                                            • user : String
                                                              Injected SSH key will let agent start as root in container. If you want to use another user configure it's name here. Please note such a user must pre-exist in container image.
                                                          • $class: 'ManuallyConfiguredSSHKey'
                                                            • credentialsId : String
                                                            • sshHostKeyVerificationStrategy
                                                                Nested Choice of Objects
                                                              • $class: 'KnownHostsFileKeyVerificationStrategy'

                                                                Checks the known_hosts file (~/.ssh/known_hosts) for the user Jenkins is executing under, to see if an entry exists that matches the current connection.

                                                                This method does not make any updates to the Known Hosts file, instead using the file as a read-only source and expecting someone with suitable access to the appropriate user account on the Jenkins controller to update the file as required, potentially using the ssh hostname command to initiate a connection and update the file appropriately.

                                                                • $class: 'ManuallyProvidedKeyVerificationStrategy'

                                                                  Checks the key provided by the remote host matches the key set by the user who configured this connection.

                                                                  • key : String

                                                                    The SSH key expected for this connection. This key should be in the form `algorithm value` where algorithm is one of ssh-rsa or ssh-dss, and value is the Base 64 encoded content of the key.

                                                                • $class: 'ManuallyTrustedKeyVerificationStrategy'

                                                                  Checks the remote key matches the key currently marked as trusted for this host.

                                                                  Depending on configuration, the key will be automatically trusted for the first connection, or an authorised user will be asked to approve the key. An authorised user will be required to approve any new key that gets presented by the remote host.

                                                                  • requireInitialManualTrust : boolean

                                                                    Require a user with Computer.CONFIGURE permission to authorise the key presented during the first connection to this host before the connection will be allowed to be established.

                                                                    If this option is not enabled then the key presented on first connection for this host will be automatically trusted and allowed for all subsequent connections without any manual intervention.

                                                                • $class: 'NonVerifyingKeyVerificationStrategy'

                                                                  Does not perform any verification of the SSH key presented by the remote host, allowing all connections regardless of the key they present.

                                                            • javaPath : String (optional)
                                                            • jvmOptions : String (optional)
                                                            • launchTimeoutSeconds : int (optional)
                                                            • maxNumRetries : int (optional)
                                                              The number of times that attempts to connect to the newly-spun Docker container will be retried before the operation is abandoned.

                                                              Note: That this field applies first to checks that the SSH port is open for new TCP connections, and secondly to checks that the SSH service that owns the TCP port is accepting SSH connections.
                                                              e.g. a value of 3 would mean that (up to) 4 attempts (1 initial attempt plus 3 retries) would be made to check the availability of the TCP port, followed by (up to) 4 attempts (1 initial attempt plus 3 retries) to check the availability of the SSH service itself.

                                                            • port : int (optional)
                                                            • prefixStartSlaveCmd : String (optional)
                                                            • retryWaitTime : int (optional)
                                                              Number of seconds to wait between attempts to connect to the newly-started Docker container.
                                                            • suffixStartSlaveCmd : String (optional)
                                                        • labelString : String
                                                          Labels to give these nodes (for limiting your builds)
                                                        • instanceCapStr : String

                                                          The maximum number of containers, based on this template, that this provider is allowed to run in total. A negative value, or zero, or 2147483647 all mean "no limit" is imposed on the this template, although the overall cloud instance limit (if any) will still apply.

                                                          Note that containers which have not been created by Jenkins are not included in this total.

                                                          As an alternative, some Docker setups can also determine the maximum number of containers automatically using memory/cpu constraints.

                                                        • disabled (optional)
                                                            Nested Object
                                                          • disabledByChoice : boolean (optional)
                                                          • enabledByChoice : boolean (optional)
                                                            If not ticked then this functionality will be disabled.
                                                            This can be used to e.g. take a cloud or template out of action for maintenance etc.

                                                            Note: If problems are encountered then this functionality may be disabled automatically. If that happens then it will be shown here. In this situation, the disabled state is transient and will automatically clear after the stated period has elapsed.

                                                        • mode (optional)
                                                          • Values: NORMAL, EXCLUSIVE
                                                        • name : String (optional)
                                                          Name prefix to use for all the Jenkins nodes created from this template.
                                                          Jenkins will append a unique ID to this name in order to create individual node names.

                                                          If blank or just whitespace, a default of "docker" will be used.

                                                        • nodeProperties (optional)
                                                          • Type: ? extends hudson.slaves.NodeProperty<?>
                                                        • pullStrategy (optional)
                                                          Pull strategy during provisioning before image run.
                                                          • Values: PULL_ALWAYS, PULL_LATEST, PULL_NEVER
                                                        • pullTimeout : int (optional)
                                                          Timeout, in seconds, to apply when expecting data from the Docker API when performing the docker pull operation. 0 means no time limit, but this is not recommended (if your docker API locks up, some aspects of Jenkins can also lock up).
                                                          i.e. you probably want this set to as long as it takes to pull the entire image onto a fresh docker server. e.g. a few minutes.

                                                          Note: This overrides the read timeout specified for the cloud, but only for the docker pull operation (as this operation is expected to take longer than most docker operations).

                                                        • remoteFs : String (optional)
                                                          Root directory within your image for the Jenkins user to use
                                                        • removeVolumes : boolean (optional)
                                                          Remove the volumes associated to the container during container remove.
                                                        • retentionStrategy (optional)

                                                          Specify the strategy when docker containers shall be started and stopped:

                                                          Docker Once Retention Strategy (default)
                                                          For each job in the queue, an own docker container is started. Once the job has finished, the container is shut down.
                                                          Docker Cloud Retention Strategy (experimental)
                                                          Based on the workload provided by the queue (load average), new docker containers are started on demand. After the job(s) have finished, the container is not shut down immediately. If no new job was executed on this agent/container during the period of the Idle delay, the container is shut down.
                                                          Keep this agent on-line as much as possible (experimental)
                                                          Starts as many containers as specified in the Instance Capacity (obeying the Container Cap) and tries to keep them always running (i.e. a new container is started in case another one belonging to this template was shut down).
                                                          Take this agent on-line according to a schedule (experimental)
                                                          Based on a cron-schedule agents are brought on-line and will keep running. Once the specified period in the schedule is over, the agents will be shut down.
                                                          Take this agent on-line when in demand and off-line when idle (experimental)
                                                          Containers are started if there are jobs waiting for execution in the queue. They are only started, if the jobs are waiting a certain threshold of time there (In demand delay). After the jobs have finished, the container is not shut down immediately. If no new job was executed on this agent/container during the period of the Idle delay, the container is shut down.
                                                            Nested Object
                                                          • idleMinutes : int
                                                            Number of minutes of idleness after which to kill the agent; serves a backup in case the strategy fails to detect the end of a task
                                                          • numberOfTasksInProgress : int (optional)
                                                          • terminateOnceDone : boolean (optional)
                                                        • stopTimeout : int (optional)
                                                          Timeout, in seconds, to apply when stopping the container after a job has finished. The default of 10s is fine for most cases. However, if you container needs to do some cleanup after the agent has stopped you can increase the timeout. If the container fails to stop gracefully before the timeout ends, the container will be killed.
                                                    • $class: 'DryRunJobProperty'
                                                      • durabilityHint

                                                        This setting allows users to change the default durability mode for running Pipelines. In most cases this is a trade-off between performance and the ability for running pipelines to resume after unplanned Jenkins outages.

                                                        What does this do?

                                                        • Previously, running pipelines wrote data constantly, so that they could resume even if Jenkins fails. This setting gives the user the ability to adjust this write behavior.
                                                        • Higher-performance/lower-durability modes write data to disk much less often for running pipelines.
                                                        • Writing data less often can massively reduce build times for Pipelines with many steps or complex logic. For pipelines which spend most of their time waiting for a shell/batch script to run, the difference will be less visible.
                                                        • Running pipelines with lower durability settings may lose data if they do not finish and Jenkins is not shut down gracefully:
                                                          • A "graceful" shutdown where Jenkins goes through a full shutdown process, such as visiting http://[jenkins-server]/exit
                                                          • A "dirty" shutdown, such as using kill -9 to terminate the Jenkins process, may prevent incomplete pipelines from persisting data
                                                        • Pipelines that cannot persist data may not be able to resume or displayed in Blue Ocean/Stage View/etc.
                                                        • Pipelines will generally write log data regardless of durability settings.
                                                        • Some modes use an "atomic write" option - this helps ensure that pipeline build files aren't overwritten or left partially written if something fails.
                                                        • Atomic writes may place more stress on filesystems, so especially with networked storage it may be faster not to use them.

                                                        Note: defaults also be set globally under Manage Jenkins > Configure System.

                                                        • hint
                                                          • Values: PERFORMANCE_OPTIMIZED, SURVIVABLE_NONATOMIC, MAX_SURVIVABILITY
                                                      • $class: 'EasyQAPluginProperties'
                                                        • siteName : String
                                                        • pluginEnabled : boolean
                                                        • failureMode
                                                          This property determines how to fail the build if the commands cannot be applied to EasyQA
                                                          • Values: NONE, UNSTABLE, FAILURE
                                                      • eiffelActivity
                                                        • categories : Array / List of String (optional)
                                                        • enforceBuildSchedule
                                                          • branches : Array / List of String (optional)
                                                          • $class: 'EnvInjectJobProperty'
                                                            • info
                                                                Nested Object
                                                              • propertiesFilePath : String

                                                                Gives a file path of a properties file. The file format must be the standard Java property file format.

                                                                The file path can be absolute or relative to the workspace (the process is executed after a SCM checkout). All the properties name will be accessible as environment variables by their names.

                                                              • propertiesContent : String

                                                                Give a set of key/value (one variable per line): KEY=VALUE.

                                                                All the properties name will be accessible as environment variables by their names. You can use or override the properties specified in the above properties file.

                                                              • scriptFilePath : String

                                                                Execute a script file aimed at setting an environment such as creating folders, copying files, and so on.
                                                                Give the script file path.
                                                                The file path can be absolute path or relative to the workspace (the process is executed after a SCM checkout).
                                                                You can use the above properties as variables.
                                                                However, adding or overriding environment variables in the script has no impact in the build job.

                                                              • scriptContent : String

                                                                Execute a script file aimed at setting an environment such as creating folders, copying files, and so on.
                                                                Give the script file content.
                                                                You can use the above properties as variables.
                                                                However, adding or overriding environment variables in the script doesn't have any impacts in the build job.

                                                              • loadFilesFromMaster : boolean

                                                                If enabled, load files (properties or scripts) from controller. Without this option, Jenkins loads the files from the target node (agent or controller). Loading the files from the controller may avoid conflicts between environment variables, such as the problematic PATH variable used on both Windows and Linux.

                                                                As of EnvInject 2.0, global configuration can disable this option. When the option has been disabled by global configuration, you will see a warning in order to flag that the option was configured by the job but is now disabled. Once the option has been turned off - to acknowledge the job has been reconfigured - the option will disappear from the UI.

                                                                It is not recommended to use this option in new jobs even if it is enabled.

                                                              • secureGroovyScript

                                                                Evaluates a Groovy script and injects the results into the environment. This script is powered by the Script Security Plugin; both Approved Script and Groovy Sandbox modes are available. For the new scripts it is recommended to use the Sandbox mode.

                                                                Usage

                                                                The groovy script must return a Map<String,String> Java object. You can access parameters and other environment variables through variables in the Groovy script. In the scripts you can also use the following variables.

                                                                currentJob
                                                                Current hudson.model.Job instance.
                                                                currentBuild
                                                                Current hudson.model.Run instance.
                                                                currentListener
                                                                Current hudson.model.TaskListener instance, which can be used for logging purposes.
                                                                out
                                                                Another logging instance as java.io.PrintStream. It is recommended to use currentListener instead of this variable when possible.

                                                                All listed variables can be used in both script modes. In the Sandbox mode the access to particular fields and methods may require an additional approval.

                                                                Example

                                                                For example, the Groovy can compute environment variables from user input parameters. The script below injects the COMPUTE_VAR environment variable according the CASE parameter value.

                                                                
                                                                          def stringValue="StRinG";
                                                                          if ("upper".equals(CASE)){
                                                                            def map = ["COMPUTE_VAR": stringValue.toUpperCase()]
                                                                            return map
                                                                          } else if ("lower".equals(CASE)){
                                                                            def map = ["COMPUTE_VAR": stringValue.toLowerCase()]
                                                                            return map
                                                                          } else {
                                                                            return null;
                                                                          }
                                                                        
                                                                  Nested Object
                                                                • script : String
                                                                • sandbox : boolean
                                                                  If checked, run this Groovy script in a sandbox with limited abilities. If unchecked, and you are not a Jenkins administrator, you will need to wait for an administrator to approve the script.
                                                                • classpath
                                                                  Additional classpath entries accessible from the script.
                                                                    Array / List of Nested Object
                                                                  • path : String
                                                                    A path or URL to a JAR file. This path should be approved by an administrator or a user with the RUN_SCRIPT permission, or the script fails. If the file or files are once approved, they are treated approved even located in another path.
                                                                  • oldPath : String (optional)
                                                                  • shouldBeApproved : boolean (optional)
                                                                • oldScript : String (optional)
                                                            • contributors (optional)
                                                                Array / List of Nested Choice of Objects
                                                              • $class: 'OntrackDSLEnvInjectJobPropertyContributor'
                                                                • scriptText : String
                                                                • ontrackLog : boolean
                                                              • $class: 'SharedObjectJobProperty'
                                                                • populateSharedObjects : boolean

                                                                  Populate as environment variables the shared objects (configured in the 'Manage Section > Shared Objects' section).
                                                                  With this option, you can dynamically inject environment variables in the build from objects in your environment.

                                                                • profiles : String

                                                                  Restrict shared objects propagation to a list of profiles.
                                                                  Give all the profiles selected.
                                                                  Each profile will be separated by a semicolon (;).

                                                              • $class: 'ToolInstallationJobProperty'
                                                                • populateToolInstallation : boolean

                                                                  Populate as environment variables the locations of installed tools (configured in the 'Manage Jenkins > Configure System' section ).
                                                                  Tool names are exposed as an environment variables. Tool Paths are the environment variable values.
                                                                  Space ( ), Dash (-) and dot (.) are replaced by an underscore (_) for tool names.

                                                            • keepBuildVariables : boolean (optional)

                                                              Inject Jenkins build variables such as EXECUTOR_NUMBER, BUILD_ID, BUILD_TAG, JOB_NAME and so on.

                                                              Inject also environment contributors and build variable contributors provided by other plugins.

                                                            • keepJenkinsSystemVariables : boolean (optional)

                                                              Inject Jenkins system variables such as JENKINS_HOME, JENKINS_URL, NODE_NAME and so on.

                                                              Inject also environment variables defined as global properties and as node properties.

                                                            • on : boolean (optional)
                                                            • overrideBuildParameters : boolean (optional)
                                                          • $class: 'FailedJobDeactivator'
                                                            • optionalBlock
                                                              Configure this job to use Failed Job Deactivator. If not configured, default values are committed (Plugin enabled).
                                                              All existing configuration will get discarded!
                                                                Nested Object
                                                              • active : boolean
                                                              • lastManuallyTriggered : int
                                                              • lastSuccessfulBuild : int
                                                              • userNotification : String
                                                          • $class: 'FeatureBranchProperty'
                                                            • upstream : String
                                                          • $class: 'GameJobProperty'
                                                            • job
                                                                Nested Choice of Objects
                                                              • $class: 'JobGenerator'
                                                                • parent
                                                                    Nested Choice of Objects
                                                                • name : String
                                                              • linkJob
                                                                • parent
                                                                    Nested Choice of Objects
                                                                • name : String
                                                            • activated : boolean (optional)
                                                            • showLeaderboard : boolean (optional)
                                                            • showTasks : boolean (optional)
                                                            • showStatistics : boolean (optional)
                                                            • currentChallengesCount : int (optional)
                                                            • currentQuestsCount : int (optional)
                                                            • currentStoredChallengesCount : int (optional)
                                                            • canSendChallenge : boolean (optional)
                                                            • searchCommitCount : int (optional)
                                                            • pitConfiguration : String (optional)
                                                            • showPitOutput : boolean (optional)
                                                          • $class: 'GitBucketProjectProperty'
                                                            • url : String
                                                            • linkEnabled : boolean
                                                          • gitLabConnection
                                                            • gitLabConnection : String
                                                            • jobCredentialId : String (optional)
                                                            • useAlternativeCredential : boolean (optional)
                                                          • giteeConnection
                                                            • giteeConnection : String
                                                          • githubProjectProperty
                                                            • projectUrlStr : String

                                                              Enter the URL for the GitHub hosted project (without the tree/master or tree/branch part).

                                                              For example: https://github.com/rails/rails for the Rails project.

                                                            • displayName : String (optional)

                                                              This value will be used as context name for commit status if status builder or status publisher is defined for this project. It should be small and clear.

                                                              If you leave it empty, job name will be used for builder and publisher.

                                                          • $class: 'GitlabLogoProperty'
                                                            • repositoryName : String
                                                              Input GitLab repository name formatted with "<group name>/<repository name>" (ex. gitlab-org/gitlab-ce)
                                                          • $class: 'GogsProjectProperty'
                                                            • gogsSecret
                                                              • Type: class hudson.util.Secret
                                                            • gogsUsePayload : boolean
                                                            • gogsBranchFilter : String
                                                          • $class: 'GraphsByBuildDates'
                                                            • checked : boolean
                                                          • $class: 'GroovyLabelAssignmentProperty'
                                                            Generates Label Expression to restrict nodes where builds of this job can run, using Groovy script.
                                                            See the help of "Restrict where this project can be run Help for feature: Restrict where this project can be run" for details of Label Expression and node restriction.
                                                            • secureGroovyScript
                                                                Nested Object
                                                              • script : String
                                                              • sandbox : boolean
                                                                If checked, run this Groovy script in a sandbox with limited abilities. If unchecked, and you are not a Jenkins administrator, you will need to wait for an administrator to approve the script.
                                                              • classpath
                                                                Additional classpath entries accessible from the script.
                                                                  Array / List of Nested Object
                                                                • path : String
                                                                  A path or URL to a JAR file. This path should be approved by an administrator or a user with the RUN_SCRIPT permission, or the script fails. If the file or files are once approved, they are treated approved even located in another path.
                                                                • oldPath : String (optional)
                                                                • shouldBeApproved : boolean (optional)
                                                              • oldScript : String (optional)
                                                          • $class: 'HeavyJobProperty'
                                                            • weight : int
                                                              Specify the number of executors that this job needs to occupy. Setting this to a bigger value is useful if your job is known to consume multiple threads, so that the scheduling decision is done accordingly — for example, say your job runs tests with 4 threads simultaneously. Specifying 4 makes Hudson schedule your builds to only run on a slave with 4 or more executors, and if your build is then run on a slave with 5 executors, the slave will have just one more available executor, making it that much less likely for Hudson to schedule additional builds on the same node.

                                                              Specifying 0 here is the same as specifying 1.

                                                          • $class: 'HipChatJobProperty'
                                                            • room : String
                                                            • startNotification : boolean
                                                            • notifyAborted : boolean
                                                            • notifyFailure : boolean
                                                            • notifyNotBuilt : boolean
                                                            • notifySuccess : boolean
                                                            • notifyUnstable : boolean
                                                            • notifyBackToNormal : boolean
                                                          • $class: 'HubotJobProperty'
                                                            • siteNames : String
                                                            • enableNotifications : boolean
                                                          • $class: 'IceScrumProjectProperty'
                                                            • url : String
                                                              Enter the URL for your iceScrum project, only works with iceScrum Jenkins integration enabled more details: here.

                                                              For example, projects hosted on icescrum.com Cloud platform : https://cloud.icescrum.com/p/TESTPROJ for the TESTPROJ project hosted on icescrum.com

                                                            • username : String
                                                              Warning! Only for old iceScrum server (R6#XX)

                                                              Set the username of the selected iceScrum user you choose. This user must have access to the selected iceScrum project with team member role.

                                                            • password
                                                              Warning! Only for old iceScrum server (R6#XX)

                                                              Set the password of your iceScrum user

                                                              • Type: class hudson.util.Secret
                                                            • accessToken : String
                                                              Set an access token from an iceScrum user account that have access to the selected project. This user must have access to the selected iceScrum project with team member role.
                                                            • authType : String
                                                          • $class: 'JiraProjectProperty'
                                                            • siteName : String
                                                          • $class: 'JobInclusionJobProperty'
                                                            • useJobGroup : boolean
                                                            • jobGroupName : String
                                                          • $class: 'JobOwnerJobProperty'
                                                            • ownershipDescription
                                                              • Type: class com.synopsys.arc.jenkins.plugins.ownership.OwnershipDescription
                                                            • security
                                                                Nested Object
                                                              • permissionsMatrix
                                                                  Nested Object
                                                                • entries
                                                                    Array / List of Nested Choice of Objects
                                                                  • group
                                                                    • name : String
                                                                    • permissions : Array / List of String
                                                                    • user
                                                                      • name : String
                                                                      • permissions : Array / List of String
                                                                      • userOrGroup
                                                                        • name : String
                                                                        • permissions : Array / List of String
                                                                      • inheritanceStrategy (optional)
                                                                          Nested Choice of Objects
                                                                        • inheritingGlobal
                                                                          • inheriting
                                                                            • nonInheriting
                                                                      • $class: 'JobPrerequisites'
                                                                        • script : String
                                                                          A script to be executed on slave node. If returning non 0 status, the node will be vetoed from hosting the build.
                                                                        • interpreter : String
                                                                          Command line interpreter ot be used for executing the prerequisite script.
                                                                      • $class: 'JobRestrictionProperty'
                                                                      • $class: 'JobTagPublisher'
                                                                        • tags (optional)
                                                                            Array / List of Nested Object
                                                                          • value : String (optional)
                                                                      • branchTearDownExecutor
                                                                        • jobName : String
                                                                      • $class: 'LeastLoadDisabledProperty'
                                                                        • leastLoadDisabled : boolean
                                                                          Disable the leastload balancer implementation and use the Jenkins default.
                                                                      • $class: 'LoggingJobProperty'
                                                                        • pollLogging : boolean
                                                                        • pruneDays : int
                                                                      • $class: 'LogstashJobProperty'
                                                                        • $class: 'MantisProjectProperty'
                                                                          • siteName : String
                                                                          • projectId : int
                                                                          • category : String
                                                                          • pattern : String
                                                                          • regex : String
                                                                          • linkEnabled : boolean
                                                                        • $class: 'MavenInfoJobConfig'
                                                                          • mainModulePattern : String
                                                                            Regular expression pattern to find module to extract versions, name, description, ....

                                                                            There are situations in wich you don't want to show root module's version. For example, when each module has its own version.
                                                                            You can select which module is used for showing version column using this pattern.

                                                                            You can use wilcards or leave a part empty to match all groups (e.g: ":my-artifact", "*.base:parent", ...).
                                                                            The pattern is checked against groupId:artifactId.
                                                                            Note: artifacts are ordered by groupId and artifactId and first matching module is used

                                                                            If no module matches or pattern is empty, root module is used.
                                                                          • dependenciesPattern : String
                                                                            Pattern to find interesting dependencies, ....

                                                                            You can use this pattern to select which dependencies are interesting to you
                                                                            E.g.: "org.springframework.*:*"

                                                                            You can use wilcards or leave a part empty to match all groups (e.g: ":my-artifact", "*.base:parent", ...).
                                                                            The pattern is checked against groupId:artifactId.

                                                                          • assignName : boolean
                                                                            If checked, Job's Visible Name will be changed with <name> tag from POM
                                                                          • nameTemplate : String
                                                                            Sometimes you want to format maven name, for example you migth add Git's branch name to Visible Name.

                                                                            You can use a formatting template (as described in Token Macro Plugin)

                                                                            E.g.: $MAVEN_NAME [$GIT_BRANCH]
                                                                          • assignDescription : boolean
                                                                            If checked, Job's Description will be changed with <description> tag from POM
                                                                          • descriptionTemplate : String
                                                                            Sometimes you want to format maven description.

                                                                            You can use a formatting template (as described in Token Macro Plugin)

                                                                        • $class: 'MavenRepoCleanerProperty'
                                                                          • notOnThisProject : boolean
                                                                        • $class: 'MetadataJobProperty'
                                                                          • values
                                                                              Array / List of Nested Choice of Objects
                                                                            • $class: 'DateMetadataValue'
                                                                              • name : String
                                                                              • description : String
                                                                              • year : int
                                                                              • month : int
                                                                              • day : int
                                                                              • details
                                                                                  Nested Object
                                                                                • hour : int
                                                                                • minute : int
                                                                                • second : int
                                                                              • exposedToEnvironment : boolean
                                                                            • $class: 'NumberMetadataValue'
                                                                              • name : String
                                                                              • description : String
                                                                              • value : long
                                                                              • exposedToEnvironment : boolean
                                                                            • $class: 'StringMetadataValue'
                                                                              • name : String
                                                                              • description : String
                                                                              • value : String
                                                                              • exposedToEnvironment : boolean
                                                                            • $class: 'TreeNodeMetadataValue'
                                                                              • name : String
                                                                              • description : String
                                                                              • children
                                                                                  Array / List of Nested Choice of Objects
                                                                                • $class: 'DateMetadataValue'
                                                                                  • name : String
                                                                                  • description : String
                                                                                  • year : int
                                                                                  • month : int
                                                                                  • day : int
                                                                                  • details
                                                                                      Nested Object
                                                                                    • hour : int
                                                                                    • minute : int
                                                                                    • second : int
                                                                                  • exposedToEnvironment : boolean
                                                                                • $class: 'NumberMetadataValue'
                                                                                  • name : String
                                                                                  • description : String
                                                                                  • value : long
                                                                                  • exposedToEnvironment : boolean
                                                                                • $class: 'StringMetadataValue'
                                                                                  • name : String
                                                                                  • description : String
                                                                                  • value : String
                                                                                  • exposedToEnvironment : boolean
                                                                                • $class: 'TreeNodeMetadataValue'
                                                                              • exposedToEnvironment : boolean
                                                                        • $class: 'NaginatorOptOutProperty'
                                                                          • optOut : boolean
                                                                            By default, naginator offers a "retry" link to all failed builds. Some jobs anyway might not be designed to support this usage, so this option let you opt-out so no rebuild option is added.
                                                                        • overrideIndexTriggers

                                                                          Allows overriding default treatment of branch indexing triggers.

                                                                          If branch indexing triggers are disabled at the multibranch or organization label, selecting this will enable them for this job only.

                                                                          Otherwise, leaving the checkbox unselected will disable branch indexing triggers for this job only.

                                                                          • enableTriggers : boolean
                                                                        • parameters
                                                                          Parameters allow you to prompt users for one or more inputs that will be passed into a build. For example, you might have a project that runs tests on demand by allowing users to upload a zip file with binaries to be tested. This could be done by adding a File Parameter here.
                                                                          Or you might have a project that releases some software, and you want users to enter release notes that will be uploaded along with the software. This could be done by adding a Multi-line String Parameter here.

                                                                          Each parameter has a Name and some sort of Value , depending on the parameter type. These name-value pairs will be exported as environment variables when the build starts, allowing subsequent parts of the build configuration (such as build steps) to access those values, e.g. by using the ${PARAMETER_NAME} syntax (or %PARAMETER_NAME% on Windows).
                                                                          This also implies that each parameter defined here should have a unique Name .

                                                                          When a project is parameterized, the usual Build Now link will be replaced with a Build with Parameters link, where users will be prompted to specify values for each of the defined parameters. If they choose not to enter anything, the build will start with the default value for each parameter.

                                                                          If a build is started automatically, for example if started by an SCM trigger, the default values for each parameter will be used.

                                                                          When a parameterized build is in the queue, attempting to start another build of the same project will only succeed if the parameter values are different, or if the Execute concurrent builds if necessary option is enabled.

                                                                          See the Parameterized Builds documentation for more information about this feature.

                                                                          • parameterDefinitions
                                                                              Array / List of Nested Choice of Objects
                                                                            • agentParameter
                                                                              • name : String
                                                                                Parameter name,required.
                                                                              • defaultValue : String (optional)
                                                                                Default agent server name,Not required.
                                                                              • description : String (optional)
                                                                            • $class: 'AppDetectorParamaterDefinition'
                                                                              • name : String
                                                                              • appName : String
                                                                              • defaultValue : String
                                                                              • description : String (optional)
                                                                            • $class: 'ArtifactRepoParamDefinition'
                                                                              Define an artifact repository from which to pull information and make it available as build parameters.
                                                                              • name : String
                                                                                The name (and label) displayed to the user when selecting settings prior to running a build.
                                                                              • serverType : String
                                                                                Select the type of the artifact repository.
                                                                                • Sonatype Nexus 3
                                                                                • JFrog Artifactory 7 / Cloud
                                                                              • serverUrl : String

                                                                                Define the URL of the repository instance.

                                                                                Example URLs
                                                                                • Artifactory OSS - http://localhost:8082/artifactory/
                                                                                • Artifactory Cloud - https://tenant.jfrog.io/artifactory/
                                                                                • Nexus - http://localhost:8081/
                                                                              • credentialsId : String

                                                                                Select the credentials to use to connect to the artifact repository instance.

                                                                                Please be aware that currently only username/password credentials are supported.

                                                                              • ignoreCertificate : boolean

                                                                                When checked the HTTP connection will ignore invalid certificates while trying to connect to the repository instance. This is useful when using an internal service with self-signed certificates.

                                                                                Use this feature with caution as it can introduce potential security risks.

                                                                              • proxy

                                                                                When checked it allows to define an HTTP proxy to be used for the outgoing connections.

                                                                                Please note that when this option is unchecked but a global proxy is defined the connection will make use of the global proxy settings. If both the local and global proxy settings are set the local proxy settings take precedence.
                                                                                  Nested Object
                                                                                • proxyProtocol : String
                                                                                • proxyHost : String
                                                                                • proxyPort : String
                                                                                • proxyCredentialsId : String
                                                                              • paramType : String

                                                                                Select the type of information to display as a build parameter.

                                                                                Artifact Path displays the name of deployed artifacts and makes the full path available.
                                                                                Artifact Version displays the version of deployed artifacts.
                                                                                Repositories displays all available artifact repositories.
                                                                              • artifactName : String
                                                                                Define a name pattern for the artifact to be found. An asterisk (*) can be used as a wildcard.

                                                                                Unfortunately the REST APIs do not allow for more powerful filter possibilities in regards to the artifact name. If more advanced filter possibilities are required please refer to the Filter Regex option within the Display Options section below.

                                                                              • repoName : String
                                                                                Allows to define a repository name. Only artifacts that exist in this repository will be listed in the result set.

                                                                                The REST API of Nexus only allows to define a single repository. To harmonize the UI it was decided to limit the possibility to define repositories for Artifactory to a single entry as well.

                                                                              • versionRegex : String

                                                                                This field allows to define a Java capturing groups to extract version information from the full artifact path. In a nutshell define a regex and define a part of a string as a group by surrounding it with ( ) brackets to define a group. The first outer group found is used to extract the version information. Following is an example for a Maven artifact with the regex .+/(\d+\.\d+(\.\d+((-CANDIDATE)?-SNAPSHOT)?)?)/.+.

                                                                                Path Version
                                                                                http://localhost:8081/maven-releases/org/example/test/1.0/test-1.0.jar 1.0
                                                                                http://localhost:8081/maven-releases/org/example/test/1.0.5/test-1.0.5.jar 1.0.5
                                                                                http://localhost:8081/maven-releases/org/example/test/1.0.5-CANDIDATE-SNAPSHOT/test-1.0.5-CANDIDATE-SNAPSHOT.jar 1.0.5-CANDIDATE-SNAPSHOT
                                                                              • repoType : Array / List of String
                                                                                • formatType : Array / List of String
                                                                                  • multiSelection : boolean
                                                                                    Check to allow multiple entries to be selectable.
                                                                                  • resultsCount : String
                                                                                    The number of results to be displayed on the parameter view. The number must be between 1 and 100.
                                                                                  • filterRegex : String

                                                                                    This allows to filter the results returned from the repository before displaying it to the user for selection. Any entry matching the regular expression will be displayed.
                                                                                    To display all entries either leave the field empty or use the regular expression .+.

                                                                                    A typical regex for Maven-based artifacts would for example look like .+/(\d+\.\d+(\.\d+(-SNAPSHOT)?)?)/.+

                                                                                  • sortOrder : String
                                                                                  • selectEntry : String
                                                                                    This option allows to define whether the first or last or any entry matching a regex should get preselected automatically. When regex is selected and the display option is a single value selection (e.g. dropdown, radio button) then the first entry matching the regex wins.
                                                                                  • selectRegex : String
                                                                                    Define a regex to match any of the entries.

                                                                                    Please note that when a regex matches multiple entries but the display style is set to either radio button or dropdown then only the first match wins as those types do not allow for multiple entries to be selected. Furthermore, the regex is always checked against the full path and not just the displayed value.

                                                                                    Example:

                                                                                    Displayed Value: artifact-1.0.0-SNAPSHOT.jar
                                                                                    Full Path: http://localhost:8081/foo/bar/com.example.group/artifact/artifact-1.0.0-SNAPSHOT.jar

                                                                                  • submitValue : String

                                                                                    By default the plugin will not only submit the label but also some hidden value containing the path of the item represented by the label. Sometimes however one only wants to get the value visible in the label. This option will allow you to choose what information will get passed along to the build script.

                                                                                    • Label + Path (default) - This will send both the label and the hidden path to the build pipeline. Both information are split by a ; (semi-colon).
                                                                                    • Label Only - This will only send the visible label text to the build pipeline.
                                                                                    • Path Only - This will only send a non-visible path of the artifact/repository to the build pipeline.

                                                                                    Example

                                                                                    Label + Path  = commons-lang3-3.12.0.jar;http://localhost:8082/repository/.../commons/commons-lang3/3.12.0/commons-lang3-3.12.0.jar
                                                                                    Label Only    = commons-lang3-3.12.0.jar
                                                                                    Path Only     = http://localhost:8082/repository/.../commons/commons-lang3/3.12.0/commons-lang3-3.12.0.jar
                                                                                            

                                                                                  • description : String (optional)
                                                                                • base64File

                                                                                  Simple file parameter compatible with Pipeline. Transmits file contents as an environment variable in Base64 encoding, so it is best used with fairly small files. Example usage from Declarative Pipeline:

                                                                                  pipeline {
                                                                                    agent any
                                                                                    parameters {
                                                                                      base64File 'FILE'
                                                                                    }
                                                                                    stages {
                                                                                      stage('Example') {
                                                                                        steps {
                                                                                          sh 'echo $FILE | base64 -d > config.yaml'
                                                                                        }
                                                                                      }
                                                                                    }
                                                                                  }
                                                                                  
                                                                                  • name : String

                                                                                    The name of the parameter. Depending on the type of parameter, this may or may not be bound as an environment variable during the build.

                                                                                    If a local filename was given, an environment variable paramname_FILENAME will also be set. If the build is triggered via the CLI, the variable will not be set.

                                                                                  • description : String (optional)
                                                                                • booleanParam
                                                                                  • name : String
                                                                                  • defaultValue : boolean (optional)
                                                                                  • description : String (optional)
                                                                                • buildMasterRelease

                                                                                  Defines a parameter where users can pick an active release from a BuildMaster application. The following environment variables will be injected into the build job:

                                                                                  • BUILDMASTER_APPLICATION_ID
                                                                                  • BUILDMASTER_APPLICATION_NAME
                                                                                  • BUILDMASTER_RELEASE_NUMBER
                                                                                  • BUILDMASTER_LATEST_BUILD_NUMBER
                                                                                  • BUILDMASTER_NEXT_BUILD_NUMBER

                                                                                  When used within pipeline script the applicationId parameter can contain either the id or name of a BuildMaster application.

                                                                                  parameters {
                                                                                    buildMasterRelease applicationId: 'TestApplication', description: '', name: 'BuildMaster Release'
                                                                                  }
                                                                                  
                                                                                  • name : String

                                                                                    The name of the parameter.

                                                                                    This value is used for display purposes only - it is not exposed as an environment variable.

                                                                                  • applicationId : String
                                                                                    The BuildMaster application to obtain the releases for.
                                                                                  • showApplicationId : boolean
                                                                                    Allows a user to select both the Application and Release at build time.

                                                                                    Triggering a build from an external source
                                                                                    As the two fields are still presented to Jenkins as a single parameter, a slightly different approach is required to to pass in both the application id and release number from other jobs or via a build api request. This is supported by separating the two values using the pipe character '|'. The applicationId is optional, can contain either an Id or applicaton name, and is only supported if this field is checked.

                                                                                    Examples
                                                                                    • ReleaseNumber: 0.0.0
                                                                                    • ApplicationId and ReleaseNumber: 1|0.0.0
                                                                                    • ApplicationName and ReleaseNumber: BuildMaster%20Application|0.0.0
                                                                                  • description : String (optional)
                                                                                • buildSelector

                                                                                  Defines a parameter that specifies how a Copy Artifact build step should select which build to copy from. Note that this parameter type is easier to use when starting the build from a browser; to specify a value via direct HTTP POST or the CLI, valid XML must be given.

                                                                                  Be aware that this string value is encoded selector configuration, and not compatible with different plugin versions.

                                                                                  • name : String
                                                                                  • defaultSelector
                                                                                      Nested Choice of Objects
                                                                                    • downstream
                                                                                      • upstreamProjectName : String

                                                                                        Copy artifacts from a build that is a downstream of a build of the specified project. You can use variable expressions.

                                                                                        Downstream builds are found using fingerprints of files. That is, a build that is triggered from a build isn't always considered downstream, but you need to fingerprint files used in builds to let Jenkins track them.

                                                                                        Note: "Downstream build of" is applicable only to AbstractProject based projects (both upstream and downstream projects).

                                                                                        AbstractProject based projects:
                                                                                        Freestyle projects
                                                                                        Multi-configuration projects
                                                                                        Maven projects
                                                                                        Non AbstractProject based projects:
                                                                                        Pipeline jobs (aka. Workflow jobs)

                                                                                      • upstreamBuildNumber : String
                                                                                        The number of the build to find its downstream build. You can also specify display names. You can use variable expressions.
                                                                                    • lastWithArtifacts
                                                                                      • lastCompleted
                                                                                        • $class: 'MultiJobBuildSelector'
                                                                                          • buildParameter
                                                                                            • parameterName : String
                                                                                              Name of the "build selector" parameter. A parameter with this name should be added in the build parameters section above. There is a special parameter type for choosing the build selector.

                                                                                              You can pass not only the parameter name, but also the parameter value itself. This is useful especially used with workflow-plugin.

                                                                                          • permalink
                                                                                            • id : String
                                                                                          • $class: 'PromotedBuildSelector'
                                                                                            • level : int
                                                                                          • latestSavedBuild
                                                                                            • specific
                                                                                              • buildNumber : String
                                                                                                While this selector is for build numbers (e.g. "22" for build #22), you can also resolve build parameters or environment variables (e.g. "${PARAM}"). The display name of a build and permalinks (e.g. "lastSuccessfulBuild", "lastBuild"...) can be used as well.
                                                                                            • lastSuccessful
                                                                                              • stable : boolean (optional)
                                                                                            • upstream
                                                                                              • allowUpstreamDependencies : boolean (optional)
                                                                                              • fallbackToLastSuccessful : boolean (optional)
                                                                                              • upstreamFilterStrategy (optional)
                                                                                                Jenkins launches only one build when multiple upstreams triggered the same project at the same time. This field specifies from which upstream build to copy artifacts in those cases. "Use the oldest" copies artifacts from the upstream build with the smallest build number (that is, oldest). "Use the newest" copies artifacts from the upstream build with the largest build number (that is, newest). The default value is "Use global setting", which behaves as configured in "Manage Jenkins" > "Configure System".
                                                                                                • Values: UseGlobalSetting, UseOldest, UseNewest
                                                                                            • workspace
                                                                                            • description : String (optional)
                                                                                          • reactiveChoice
                                                                                            • name : String
                                                                                            • randomName : String
                                                                                            • script
                                                                                                Nested Choice of Objects
                                                                                              • groovyScript

                                                                                                Use a Groovy script to define the parameter.

                                                                                                The Script will be evaluated first, and if it fails (e.g. throws an exception), the Fallback Script will be used as a fallback.

                                                                                                This script integrates with Script Security plugin to allow regular Jenkins users to configure this parameter, while limiting what they can do for security.

                                                                                                If this script is used for any of the HTML choice types of an Active Choices Reactive Reference Parameter, the resulting HTML output will be sanitized to remove everything but basic formatting, like script tags, unless the script runs outside the sandbox. This mode requires approval from a Jenkins administrator to prevent cross-site scripting (HTML) and arbitrary code execution (Groovy).

                                                                                                • script
                                                                                                    Nested Object
                                                                                                  • script : String
                                                                                                  • sandbox : boolean
                                                                                                    If checked, run this Groovy script in a sandbox with limited abilities. If unchecked, and you are not a Jenkins administrator, you will need to wait for an administrator to approve the script.
                                                                                                  • classpath
                                                                                                    Additional classpath entries accessible from the script.
                                                                                                      Array / List of Nested Object
                                                                                                    • path : String
                                                                                                      A path or URL to a JAR file. This path should be approved by an administrator or a user with the RUN_SCRIPT permission, or the script fails. If the file or files are once approved, they are treated approved even located in another path.
                                                                                                    • oldPath : String (optional)
                                                                                                    • shouldBeApproved : boolean (optional)
                                                                                                  • oldScript : String (optional)
                                                                                                • fallbackScript
                                                                                                    Nested Object
                                                                                                  • script : String
                                                                                                  • sandbox : boolean
                                                                                                    If checked, run this Groovy script in a sandbox with limited abilities. If unchecked, and you are not a Jenkins administrator, you will need to wait for an administrator to approve the script.
                                                                                                  • classpath
                                                                                                    Additional classpath entries accessible from the script.
                                                                                                      Array / List of Nested Object
                                                                                                    • path : String
                                                                                                      A path or URL to a JAR file. This path should be approved by an administrator or a user with the RUN_SCRIPT permission, or the script fails. If the file or files are once approved, they are treated approved even located in another path.
                                                                                                    • oldPath : String (optional)
                                                                                                    • shouldBeApproved : boolean (optional)
                                                                                                  • oldScript : String (optional)
                                                                                              • scriptlerScript
                                                                                                • scriptlerBuilder
                                                                                                    Nested Object
                                                                                                    Execute a scriptler script with a job, this allows the automation of many administration tasks or to provide prepared scripts for privileged users.
                                                                                                    Select the script you want to execute during the build. The scripts available are the ones marked by the admin as 'allow for users with RunScripts permission'.

                                                                                                    The parameters can be passed via job params or by creating these in this builder config.

                                                                                                  • builderId : String
                                                                                                  • scriptId : String
                                                                                                  • propagateParams : boolean
                                                                                                  • parameters
                                                                                                      Array / List of Nested Object
                                                                                                    • name : String
                                                                                                    • value : String
                                                                                                • isSandboxed : boolean
                                                                                                • parameters (optional)
                                                                                                  • Type: java.util.Map<java.lang.String, java.lang.String>
                                                                                                • scriptlerScriptId : String (optional)
                                                                                            • choiceType : String
                                                                                            • referencedParameters : String
                                                                                            • filterable : boolean
                                                                                            • filterLength : int
                                                                                            • description : String (optional)
                                                                                          • checkboxParameter
                                                                                            • name : String
                                                                                              The parameter name, which can be used to read the selected value in the build script. Multiple selected values are separated by ",", such as: value1, value2, value3...
                                                                                            • pipelineSubmitContent : String
                                                                                            • description : String (optional)
                                                                                              Parameter Description.
                                                                                            • protocol (optional)
                                                                                              Use Protocol: HTTP_HTTPS, FILE_PATH, FILE_PATH stands for file system path, HTTP_HTTPS refers to HTTP or HTTPS protocol.
                                                                                              If you choose HTTP_HTTPS, please fill in the URL of the file in the URI, for example: https://raw.githubusercontent.com/sunweisheng/Jenkins/master/xxx.yaml
                                                                                              If you choose FILE_PATH, please fill in the file path in the URI such as: /opt/xxx.yaml or C:\xxx.yaml
                                                                                              • Values: HTTP_HTTPS, FILE_PATH
                                                                                            • format (optional)
                                                                                              Select the file format, such as YAML file or JSON file.
                                                                                              • Values: YAML, JSON, Empty
                                                                                            • uri : String (optional)
                                                                                              Select HTTP_HTTPS, URI, please fill in the URL address.
                                                                                              Select FILE_PATH, URI, please fill in the file path.
                                                                                            • displayNodePath : String (optional)
                                                                                              Specify the node path used for the check box display content (this format is common to different formats), the root in the file is represented by "//", and the nodes are separated by "/", such as YAML file content:

                                                                                              CheckboxParameter:
                                                                                              - key: key-1
                                                                                              value: value-1
                                                                                              - key: key-2
                                                                                              value: value-2
                                                                                              - key: key-3
                                                                                              value: value-3

                                                                                              Display node path:
                                                                                              //CheckboxParameter/key
                                                                                              Value node path:
                                                                                              //CheckboxParameter/value
                                                                                              Then, there will be three check boxes, of which the display contents of the check boxes are: key-1, key-2, key-3, and the values obtained after checking the check boxes are: value-1, value-2 , Value-3
                                                                                            • valueNodePath : String (optional)
                                                                                              Specify the node path used for the check box selection value (this path format is common to different formats). The root in the file is represented by "//", and the nodes are separated by "/", such as the content of the YAML file:

                                                                                              CheckboxParameter:
                                                                                              - key: key-1
                                                                                              value: value-1
                                                                                              - key: key-2
                                                                                              value: value-2
                                                                                              - key: key-3
                                                                                              value: value-3

                                                                                              Display node path:
                                                                                              //CheckboxParameter/key
                                                                                              Value node path:
                                                                                              //CheckboxParameter/value
                                                                                              Then, there will be three check boxes, of which the display contents of the check boxes are: key-1, key-2, key-3, and the values obtained after checking the check boxes are: value-1, value-2 , Value-3
                                                                                            • useInput : boolean (optional)
                                                                                              Ignore the URI setting of the remote file acquisition or the local file URI setting, and use the input file content as the file content to be read.
                                                                                            • submitContent : String (optional)
                                                                                              After selecting the "Use only the input as the document content" check box, you can directly enter the YAML format or JSON format content of the configuration check box. The content format is set by the "document format" option, and the URI will be ignored after directly entering the configuration content Settings.
                                                                                          • activeChoice
                                                                                            • name : String
                                                                                            • randomName : String
                                                                                            • script
                                                                                                Nested Choice of Objects
                                                                                              • groovyScript

                                                                                                Use a Groovy script to define the parameter.

                                                                                                The Script will be evaluated first, and if it fails (e.g. throws an exception), the Fallback Script will be used as a fallback.

                                                                                                This script integrates with Script Security plugin to allow regular Jenkins users to configure this parameter, while limiting what they can do for security.

                                                                                                If this script is used for any of the HTML choice types of an Active Choices Reactive Reference Parameter, the resulting HTML output will be sanitized to remove everything but basic formatting, like script tags, unless the script runs outside the sandbox. This mode requires approval from a Jenkins administrator to prevent cross-site scripting (HTML) and arbitrary code execution (Groovy).

                                                                                                • script
                                                                                                    Nested Object
                                                                                                  • script : String
                                                                                                  • sandbox : boolean
                                                                                                    If checked, run this Groovy script in a sandbox with limited abilities. If unchecked, and you are not a Jenkins administrator, you will need to wait for an administrator to approve the script.
                                                                                                  • classpath
                                                                                                    Additional classpath entries accessible from the script.
                                                                                                      Array / List of Nested Object
                                                                                                    • path : String
                                                                                                      A path or URL to a JAR file. This path should be approved by an administrator or a user with the RUN_SCRIPT permission, or the script fails. If the file or files are once approved, they are treated approved even located in another path.
                                                                                                    • oldPath : String (optional)
                                                                                                    • shouldBeApproved : boolean (optional)
                                                                                                  • oldScript : String (optional)
                                                                                                • fallbackScript
                                                                                                    Nested Object
                                                                                                  • script : String
                                                                                                  • sandbox : boolean
                                                                                                    If checked, run this Groovy script in a sandbox with limited abilities. If unchecked, and you are not a Jenkins administrator, you will need to wait for an administrator to approve the script.
                                                                                                  • classpath
                                                                                                    Additional classpath entries accessible from the script.
                                                                                                      Array / List of Nested Object
                                                                                                    • path : String
                                                                                                      A path or URL to a JAR file. This path should be approved by an administrator or a user with the RUN_SCRIPT permission, or the script fails. If the file or files are once approved, they are treated approved even located in another path.
                                                                                                    • oldPath : String (optional)
                                                                                                    • shouldBeApproved : boolean (optional)
                                                                                                  • oldScript : String (optional)
                                                                                              • scriptlerScript
                                                                                                • scriptlerBuilder
                                                                                                    Nested Object
                                                                                                    Execute a scriptler script with a job, this allows the automation of many administration tasks or to provide prepared scripts for privileged users.
                                                                                                    Select the script you want to execute during the build. The scripts available are the ones marked by the admin as 'allow for users with RunScripts permission'.

                                                                                                    The parameters can be passed via job params or by creating these in this builder config.

                                                                                                  • builderId : String
                                                                                                  • scriptId : String
                                                                                                  • propagateParams : boolean
                                                                                                  • parameters
                                                                                                      Array / List of Nested Object
                                                                                                    • name : String
                                                                                                    • value : String
                                                                                                • isSandboxed : boolean
                                                                                                • parameters (optional)
                                                                                                  • Type: java.util.Map<java.lang.String, java.lang.String>
                                                                                                • scriptlerScriptId : String (optional)
                                                                                            • choiceType : String
                                                                                            • filterable : boolean
                                                                                            • filterLength : int
                                                                                            • description : String (optional)
                                                                                          • choice
                                                                                            • name : String
                                                                                            • description : String (optional)
                                                                                            • choices : Object (optional)
                                                                                          • $class: 'ClearCaseUcmBaselineParameterDefinition'
                                                                                            When used, this parameter will display a field at build-time so that the user is able to select the ClearCase UCM baseline from which to download the content to be worked with by this project.
                                                                                            To use this parameter, you MUST also set the SCM to be the ClearCase UCM baseline one, otherwise the build will fail.
                                                                                            The name of the selected ClearCase UCM baseline is available through the CLEARCASE_BASELINE environment variable.
                                                                                            • pvob : String
                                                                                              Mandatory — Name of the ClearCase UCM PVOB.
                                                                                            • component : String
                                                                                              Mandatory — Name of the ClearCase UCM component which owns the ClearCase UCM baseline to download at build-time.
                                                                                              At build-time, the user will be able to select one of the ClearCase UCM baselines defined for this component.
                                                                                            • promotionLevel : String
                                                                                              Optional — Promotion level of the ClearCase UCM baseline to be downloaded at build-time.
                                                                                              If no promotion level is set (blank field), then the user will be presented with all the ClearCase UCM baselines belonging to the ClearCase UCM component defined above. If a promotion level is set, then, at build-time, the user will be presented with only the ClearCase UCM baselines which have been promoted to the specified level.
                                                                                            • stream : String
                                                                                              Optional — Stream of the ClearCase UCM baseline to be downloaded at build-time.
                                                                                              If no stream is set (blank field), then the user will be presented with all the ClearCase UCM baselines belonging to the ClearCase UCM component defined above. If a stream is set, then, at build-time, the user will be presented with only the ClearCase UCM baselines which have been defined on this stream.
                                                                                            • restrictions : String
                                                                                              Optional — List of folders (one folder per line) to be actually downloaded from ClearCase.
                                                                                              For this field to be taken into account, you need to check the Use snapshot view field.
                                                                                              If no restrictions are defined, then all the data for the selected ClearCase UCM baseline will be downloaded. If restrictions are defined, then only these folders will be downloaded.
                                                                                              For each folder to download, don't forget to prefix them with the VOB name and the component root dir (usually identical to the component name) this folder belongs to. For example, if you want to download the folder 05_impl/0_src which is in the fa4_web component of the fa4 VOB, set the value to /fa/fa4_web/05_impl/0_src.
                                                                                            • viewName : String
                                                                                              Mandatory — Name of the ClearCase UCM view which will be created to download the content of the baseline selected at build-time.
                                                                                              You can use several variables within the view name, such as:
                                                                                              • CLEARCASE_BASELINE, which is replaced with the name of the ClearCase UCM baseline which is selected at build-time;
                                                                                              • JOB_NAME, which is replaced with the name of the job;
                                                                                              • USER_NAME, which is replaced with the name of the user running Hudson.
                                                                                              The ClearCase UCM view is available as two environment variables:
                                                                                              • The name of the ClearCase UCM view is available as CLEARCASE_VIEWNAME;
                                                                                              • The absolute path to the ClearCase UCM view is available as CLEARCASE_VIEWPATH.
                                                                                            • mkviewOptionalParam : String
                                                                                              Optional — If your build requires additional cleartool arguments when creating a view using mkview, specify them here.
                                                                                              Note that all other arguments (that is, -snapshot —if applicable— and -tag ${CLEARCASE_VIEWNAME} will be appended before these additional arguments.
                                                                                              For documentation on the mkview command, take a look at the ClearCase 7.0 Information Center.
                                                                                            • snapshotView : boolean
                                                                                            • useUpdate : boolean
                                                                                              Check this option to avoid recreating the Clearcase UCM view each time a build is triggered and the baseline has changed. Instead, the view config spec will be updated so that only files that have changed are loaded.
                                                                                            • forceRmview : boolean
                                                                                              Check this option to force the recreation of the ClearCase UCM view each time a build is triggered. If this option is not set and if the baseline which is selected when a new build is triggered is the same as for the previous build, then the ClearCase UCM view won't be recreated.
                                                                                              This setting can be overriden at run-time.
                                                                                            • excludeElementCheckedout : boolean
                                                                                              Check this option to exclude the element * CHECKEDOUT rule from the config spec.
                                                                                              Note that the element * CHECKEDOUT rule is mandatory when using snapshot views.
                                                                                            • moreRecentThan : String
                                                                                              Optional — Use this field to display, when triggering a new build, only the ClearCase UCM baselines which are more recent than a given number of years, or months, or weeks, or days.
                                                                                              Examples: 1 year, 6 months, 1 week, 10 days
                                                                                            • uuid : String
                                                                                            • description : String (optional)
                                                                                          • $class: 'CloudSelectorParameter'
                                                                                            • description : String (optional)
                                                                                          • credentials
                                                                                            Defines a credentials parameter, which you can use during a build.

                                                                                            For security reasons, the credential is NOT directly exposed, the ID of the credential is exposed.

                                                                                            However, the selected credential is available through variable substitution in some other parts of the configuration. The string value will be the ID of the credential. A supporting plugin can thus use the ID to retrieve the selected credential and expose it to the build in an appropriate way.
                                                                                            • name : String
                                                                                            • defaultValue : String
                                                                                              The default credentials to use.
                                                                                            • credentialType : String
                                                                                            • required : boolean
                                                                                              When this option is selected, the credentials selection drop down will not provide the empty selection as one of the options. This will not prevent a build without a value if there are no credentials available, for example if the job does not have access to any credentials of the correct type or there is no default value and the user starting the build either does not have any credentials of the correct type in their personal credentials store or they do not have permissions on the job to use credentials from their personal store.
                                                                                            • description : String (optional)
                                                                                          • $class: 'CvsTagsParamDefinition'
                                                                                            • name : String
                                                                                              The name this parameter will be referred to as during any builds.
                                                                                            • cvsRoot : String
                                                                                            • passwordRequired : boolean
                                                                                            • password : String
                                                                                            • moduleName : String
                                                                                              The name of the item to retrieve a list of symbolic names for. This could be a module root (e.g. moduleName), subdirectory (e.g. moduleName/sub/directory/) or individual file (e.g. moduleName/sub/directory/file.name).
                                                                                            • description : String (optional)
                                                                                          • $class: 'DateParameterDefinition'
                                                                                            • name : String
                                                                                            • dateFormat : String
                                                                                              This is the Java date format. Like 'yyyyMMdd'.
                                                                                            • defaultValue : String
                                                                                              You can create a 'default value' in one of two forms.

                                                                                              1. Java LocalDate or LocalDateTime code style

                                                                                              • LocalDate.now();
                                                                                              • LocalDate.now().plusDays(1);
                                                                                              • LocalDate.now().plusDays(1).plusYears(2);
                                                                                              • LocalDate.now().minusDays(5).minusMonths(3).minusYears(2);
                                                                                              • LocalDateTime.now()
                                                                                              • LocalDateTime.now().minusHours(5).plusMinutes(10).minusSeconds(20);
                                                                                              • LocalDateTime.now().minusDays(5).plusYears(5).plusSeconds(50);

                                                                                              2. LocalDate String (This case should match the format of 'dateFormat')

                                                                                              • 20170501
                                                                                              • 2017-05-01
                                                                                            • description : String (optional)
                                                                                          • $class: 'DeployMetaDataParameterDefinition'
                                                                                            A deployment meta data parameter allows you to specify environment and build version to deploy that will be used in "Collect deploy metadata" plugin.
                                                                                            • name : String
                                                                                            • environmentKey : String
                                                                                            • buildVersion : String
                                                                                            • applicationName : String
                                                                                            • description : String (optional)
                                                                                          • activeChoiceHtml
                                                                                            • name : String
                                                                                            • randomName : String
                                                                                            • script
                                                                                                Nested Choice of Objects
                                                                                              • groovyScript

                                                                                                Use a Groovy script to define the parameter.

                                                                                                The Script will be evaluated first, and if it fails (e.g. throws an exception), the Fallback Script will be used as a fallback.

                                                                                                This script integrates with Script Security plugin to allow regular Jenkins users to configure this parameter, while limiting what they can do for security.

                                                                                                If this script is used for any of the HTML choice types of an Active Choices Reactive Reference Parameter, the resulting HTML output will be sanitized to remove everything but basic formatting, like script tags, unless the script runs outside the sandbox. This mode requires approval from a Jenkins administrator to prevent cross-site scripting (HTML) and arbitrary code execution (Groovy).

                                                                                                • script
                                                                                                    Nested Object
                                                                                                  • script : String
                                                                                                  • sandbox : boolean
                                                                                                    If checked, run this Groovy script in a sandbox with limited abilities. If unchecked, and you are not a Jenkins administrator, you will need to wait for an administrator to approve the script.
                                                                                                  • classpath
                                                                                                    Additional classpath entries accessible from the script.
                                                                                                      Array / List of Nested Object
                                                                                                    • path : String
                                                                                                      A path or URL to a JAR file. This path should be approved by an administrator or a user with the RUN_SCRIPT permission, or the script fails. If the file or files are once approved, they are treated approved even located in another path.
                                                                                                    • oldPath : String (optional)
                                                                                                    • shouldBeApproved : boolean (optional)
                                                                                                  • oldScript : String (optional)
                                                                                                • fallbackScript
                                                                                                    Nested Object
                                                                                                  • script : String
                                                                                                  • sandbox : boolean
                                                                                                    If checked, run this Groovy script in a sandbox with limited abilities. If unchecked, and you are not a Jenkins administrator, you will need to wait for an administrator to approve the script.
                                                                                                  • classpath
                                                                                                    Additional classpath entries accessible from the script.
                                                                                                      Array / List of Nested Object
                                                                                                    • path : String
                                                                                                      A path or URL to a JAR file. This path should be approved by an administrator or a user with the RUN_SCRIPT permission, or the script fails. If the file or files are once approved, they are treated approved even located in another path.
                                                                                                    • oldPath : String (optional)
                                                                                                    • shouldBeApproved : boolean (optional)
                                                                                                  • oldScript : String (optional)
                                                                                              • scriptlerScript
                                                                                                • scriptlerBuilder
                                                                                                    Nested Object
                                                                                                    Execute a scriptler script with a job, this allows the automation of many administration tasks or to provide prepared scripts for privileged users.
                                                                                                    Select the script you want to execute during the build. The scripts available are the ones marked by the admin as 'allow for users with RunScripts permission'.

                                                                                                    The parameters can be passed via job params or by creating these in this builder config.

                                                                                                  • builderId : String
                                                                                                  • scriptId : String
                                                                                                  • propagateParams : boolean
                                                                                                  • parameters
                                                                                                      Array / List of Nested Object
                                                                                                    • name : String
                                                                                                    • value : String
                                                                                                • isSandboxed : boolean
                                                                                                • parameters (optional)
                                                                                                  • Type: java.util.Map<java.lang.String, java.lang.String>
                                                                                                • scriptlerScriptId : String (optional)
                                                                                            • choiceType : String
                                                                                            • referencedParameters : String
                                                                                            • omitValueField : boolean
                                                                                            • description : String (optional)
                                                                                          • editableChoice

                                                                                            Display choices but allows inputting any values even not in choices. Works just like suggestion.

                                                                                            To use in pipeline:

                                                                                            editableChoice(
                                                                                              name: 'PARAM1',
                                                                                              choices: ['Apple', 'Grape', 'Orange'],
                                                                                              // belows are optional paramters
                                                                                              defaultValue: 'Grape',
                                                                                              restrict: true,
                                                                                              filterConfig: filterConfig(
                                                                                                prefix: true,
                                                                                                caseInsensitive: true,
                                                                                              ),
                                                                                            )
                                                                                            

                                                                                            • name : String
                                                                                            • choices : Array / List of String (optional)
                                                                                              • choicesWithText : String (optional)
                                                                                                Choices delimited with new line letters like:
                                                                                                choice1
                                                                                                choice2
                                                                                                choice3
                                                                                                
                                                                                              • defaultValue : String (optional)
                                                                                              • description : String (optional)
                                                                                              • filterConfig (optional)
                                                                                                Filter choices with input value. It works just like suggestion.
                                                                                                  Nested Object
                                                                                                • caseInsensitive : boolean (optional)
                                                                                                • prefix : boolean (optional)

                                                                                                  Display values when their prefix matches the input. Otherwise, display values when they contains the input.

                                                                                                  Example:

                                                                                                  Choices
                                                                                                  apple
                                                                                                  orange
                                                                                                  grape
                                                                                                  
                                                                                                  Current input
                                                                                                  ap
                                                                                                  values displayed when "Filter only with prefix" is enabled
                                                                                                  apple
                                                                                                  values displayed when "Filter only with prefix" is disabled
                                                                                                  apple
                                                                                                  grape

                                                                                              • restrict : boolean (optional)
                                                                                                Restrict input values to be a value in choices.
                                                                                              • withDefaultValue (optional)
                                                                                                The top most value will be the default value if not specified.
                                                                                                  Nested Object
                                                                                                • defaultValue : String
                                                                                            • $class: 'ExtensibleChoiceParameterDefinition'
                                                                                            • file
                                                                                              • name : String
                                                                                              • description : String (optional)
                                                                                            • fileSystemList
                                                                                              The filesystem-list-parameter-plugin lists file system object names of a directory. One of the object names can be selected as build parameter. In addition the objects can be filtered: ALL, DIRECTORY, FILE, SYMLINK. The order of the list can be reversed.
                                                                                              • name : String
                                                                                                The name of the parameter.
                                                                                              • nodeName : String
                                                                                              • path : String
                                                                                                The path of the directory containing the file system objects.
                                                                                              • defaultValue : String
                                                                                                Only one value can be pre-selected as default when the value is contained in object list. (Multi select default is not supported for now!)
                                                                                              • selectedType : String
                                                                                                Objects in "Path" can be filtered: ALL, DIRECTORY, FILE, SYMLINK.
                                                                                              • formSelectType : String
                                                                                              • regexIncludePattern : String
                                                                                                The regular expression matching the file system objects to be excluded in parameter selection. (Will be ignored if empty) See Standard Java regular expression.
                                                                                              • regexExcludePattern : String
                                                                                                The regular expression matching the file system objects to be included in parameter selection. (Will be ignored if empty) See Standard Java regular expression.
                                                                                              • sortByLastModified : boolean
                                                                                                If true, the list of the parameter values will be sorted by last modified file attribute. Default order is sort by parameter value.
                                                                                              • sortReverseOrder : boolean
                                                                                                If true, the list of the parameter values will be sorted in reverse order.
                                                                                              • includePathInValue : boolean
                                                                                                If true, the path will be concatenated with the selected value.
                                                                                              • description : String (optional)
                                                                                                The type of the file system objects that will be filtered from path.
                                                                                            • $class: 'GeneratorChoiceParameterDefinition'
                                                                                              • name : String
                                                                                              • choices : String
                                                                                              • description : String (optional)
                                                                                            • $class: 'GeneratorKeyValueParameterDefinition'
                                                                                              • name : String
                                                                                              • defaultValue : String (optional)
                                                                                              • description : String (optional)
                                                                                              • trim : boolean (optional)
                                                                                                Strip whitespace from the beginning and end of the string.
                                                                                            • gitParameter

                                                                                              When used, this parameter will present at build-time a choice to select a Git tag (or revision number) which set a parameter for parametrized build.

                                                                                              Be aware that git does not allow us get additional information (like author/commmit date) from a remote URL this plugin will silently clone the project when your workspace is empty. This may take a long time when we have a slow connection and/or the checkout is big.

                                                                                              Often the parameter defined in the "Name" field is used to specify the branch of the git checkout.

                                                                                              • name : String
                                                                                                The name of the parameter.
                                                                                              • type : String
                                                                                                The type of the list of parameters:
                                                                                                • Tag - list of all commit tags in repository - returns Tag Name
                                                                                                • Branch - list of all branch in repository - returns Branch Name
                                                                                                • Revision - list of all revision sha1 in repository followed by its author and date - returns Tag SHA1
                                                                                              • defaultValue : String
                                                                                                This value is returned when the list is empty or if an error occurs while retrieving data.
                                                                                              • branch : String
                                                                                                Name of branch to look in. Used only if listing revisions.
                                                                                              • branchFilter : String
                                                                                                Regex used to filter displayed branches. If blank, the filter will default to ".*".
                                                                                                Remote branches will be listed with the remote name first. E.g., "origin/master"
                                                                                              • tagFilter : String
                                                                                                This parameter is used to get tag from git.
                                                                                                If is blank, parameter is set to "*".
                                                                                                Properly is executed command: git ls-remote -t <repository> "*" or git ls-remote -t <repository> "$tagFilter".
                                                                                                git-ls-remote documentation.
                                                                                              • sortMode
                                                                                                Select how to sort the downloaded parameters. Only applies to a branch or a tag.
                                                                                                • none
                                                                                                • ascending smart
                                                                                                • descending smart
                                                                                                • ascending
                                                                                                • descending
                                                                                                When smart sorting is chosen, the compare treats a sequence of digits as a single character.
                                                                                                • Values: NONE, ASCENDING_SMART, DESCENDING_SMART, ASCENDING, DESCENDING
                                                                                              • selectedValue
                                                                                                Which value is selected, after loaded parameters.
                                                                                                If you choose 'default', but default value is not present on the list, nothing is selected.
                                                                                                • Values: NONE, TOP, DEFAULT
                                                                                              • useRepository : String
                                                                                                If in the task are defined multiple repositories, this option specifies which the repository is taken into account on getting data.
                                                                                                If the option is not defined, is taken a first defined repository.
                                                                                                This option is a regular expression, which is compared to the 'Repository URL'.
                                                                                              • quickFilterEnabled : boolean
                                                                                                When this option is enabled will show a text field.
                                                                                                Parameter is filtered on the fly.
                                                                                              • description : String (optional)
                                                                                                A description that will be shown to the user later.
                                                                                              • listSize : String (optional)
                                                                                                Specify the number of items the list will display. A value of 0 will display as a DropDown list.
                                                                                              • requiredParameter : boolean (optional)
                                                                                                When this option is selected the user must select an option or an error will be thrown(default values are ignored)
                                                                                            • $class: 'GlobalVariableStringParameterDefinition'
                                                                                              • name : String
                                                                                              • defaultValue : String (optional)
                                                                                              • description : String (optional)
                                                                                              • trim : boolean (optional)
                                                                                                Strip whitespace from the beginning and end of the string.
                                                                                            • imageTag
                                                                                              This parameter lets the user specity image tag to be used at the start of each build.
                                                                                              • name : String
                                                                                                The name of the parameter
                                                                                                These parameters are exposed to build as environment variables.
                                                                                              • image : String
                                                                                                Full Image name for tags to be listed. One Docker Hub offical most used image (e.g ubuntu) are usualy in library namespace: library/ubuntu
                                                                                              • filter : String
                                                                                                Regular expression to filter image tag e.g. v(\d+\.)*\d+ for tags like v23.3.2
                                                                                              • registry : String
                                                                                                A Docker V2 API registry where to locate images and tags.
                                                                                                You can change the default value in Jenkins Configuration Page.
                                                                                              • credentialId : String
                                                                                                Credential (username with password) to authenticate against the registry
                                                                                              • description : String (optional)
                                                                                                A description that will be shown to the user later.
                                                                                              • defaultTag : String (optional)
                                                                                                Specify a tag value that should get preselected selected as default (e.g.: v1.0 for the image myImage:v1.0)
                                                                                                NOTE: the defaultTag will get string compared to the fetched tags and if no equal exists will get ignored
                                                                                              • tagOrder (optional)
                                                                                                Allows the user to alter the ordering of the ImageTags in the build parameter.

                                                                                                Natural Ordering ... same Ordering as the tags had in prior versions
                                                                                                Reverse Natural Ordering ... the reversed original ordering
                                                                                                Descending Versions ... attempts to pars the tags to a version and order them descending
                                                                                                Ascending Versions ... attempts to pars the tags to a version and order them ascending

                                                                                                WARNING:
                                                                                                Careful with Versioned sorting, this works best with semver or maven version compliant ImageTags, but won't work at all under certain circumstances!
                                                                                                The conversion from tags to versions can fail in certain cases and cause the sorting to fail, which will result in an empty selection list.
                                                                                                In such a case the user will get notified about a parameter misconfiguration.
                                                                                                • Values: NATURAL, REV_NATURAL, DSC_VERSION, ASC_VERSION
                                                                                              • verifySsl : boolean (optional)
                                                                                                Specify if Certificate validation will be performed
                                                                                            • $class: 'InheritableStringParameterDefinition'
                                                                                              • name : String
                                                                                              • inheritanceMode : String
                                                                                                This field selects, how this parameter is altered, when a child project overrides its value. For example, you may provide a variable "A" here with the value "Foo", while a child also defines "A", but with the value "Bar".

                                                                                                The mode that you select here will influence the final value of the parameter, when you build the child:

                                                                                                • If you select "Overwritable", the build will just get the value "Bar"
                                                                                                • If you select "Extensible", the build will get the value "FooBar" (or "Foo Bar", depending on the "Whitespace Mode" below)
                                                                                                • If you select "Fixed", then the build will fail, since this project prohibited changing the value.
                                                                                                Do note, that this field only has an effect on the child parameter — not the other way around. In other words, this mode decides what will happen in the future, not what happens "now" to the current or earlier overrides.
                                                                                              • mustHaveDefaultValue : boolean
                                                                                              • mustBeAssigned : boolean
                                                                                              • whitespaceMode : String
                                                                                                This field allows you to select, how whitespaces at the start/end of the parameter should be handled, when a build is started:
                                                                                                1. Trim all leading/trailing whitespace from the entered value.
                                                                                                2. Keep the whitespace intact, exactly as the user entered it.
                                                                                                3. Keep the whitespace, but make sure that at least a single space is added to the front of the value, in case it extends a parameter with the same name from a parent.
                                                                                                Select the first option, if you know the parameter should not have leading or trailing spaces.
                                                                                                Select the third option, if you are constructing a parameter that is used in flag- or command-construction. For example Compiler Flags.
                                                                                                Otherwise, or if in doubt, just select the second option.

                                                                                                Do note that, if trimming is selected, this has an effect on both the default value used for automatically started builds, as well as user-initiated builds where the user had a chance to alter the parameter value.

                                                                                              • isHidden : boolean
                                                                                                If this is checked, the parameter will be hidden behind an "advanced" button on the screen for starting a build. For sanity's sake, you should set this for all mandatory variables that are rarely changed.
                                                                                              • defaultValue : String (optional)
                                                                                              • description : String (optional)
                                                                                              • trim : boolean (optional)
                                                                                                Strip whitespace from the beginning and end of the string.
                                                                                            • $class: 'InheritableStringParameterReferenceDefinition'
                                                                                              • name : String
                                                                                              • defaultValue : String (optional)
                                                                                              • description : String (optional)
                                                                                              • trim : boolean (optional)
                                                                                                Strip whitespace from the beginning and end of the string.
                                                                                            • $class: 'JFrogPipelinesParameter'
                                                                                              • name : String
                                                                                              • defaultValue : String (optional)
                                                                                              • description : String (optional)
                                                                                              • trim : boolean (optional)
                                                                                                Strip whitespace from the beginning and end of the string.
                                                                                            • $class: 'JavaParameterDefinition'
                                                                                              This parameter lets the user specify JDK to be used at the star of each build.
                                                                                              • name : String
                                                                                                The name to be displayed on the build parameters page.
                                                                                              • defaultJDK : String
                                                                                                The JDK that will be used if the user does not specify one.
                                                                                              • allowedJDKs : Array / List of String
                                                                                                The JDKs that can be chosen from on the build parameters page.
                                                                                                • description : String (optional)
                                                                                                  The description to be shown on the build parameters page.
                                                                                              • $class: 'JiraIssueParameterDefinition'
                                                                                                • name : String
                                                                                                • jiraIssueFilter : String
                                                                                                  Specify the JQL search on Jira instance. For a build, Jenkins will run this query, populate a drop-down list box, then ask the user to select one.
                                                                                                • description : String (optional)
                                                                                                • altSummaryFields : String (optional)

                                                                                                  Optionally, specify a comma-delimited list of fields to use instead of the issue summary as the title in the dropdown. Fields will be concatenated with spaces.

                                                                                                  Example:

                                                                                                  Field1,Field2
                                                                                              • $class: 'JiraVersionParameterDefinition'
                                                                                                • name : String
                                                                                                • jiraProjectKey : String

                                                                                                  Specify the project key. A project key is the all capitals part before the issue number in Jira.

                                                                                                  (EXAMPLE-100)

                                                                                                • jiraReleasePattern : String

                                                                                                  Specify a regular expression which release names have to match to be listed. Leave this blank to match all issues.

                                                                                                  Example:

                                                                                                  v[0-9]+([.][0-9]+)+ will match v1.0.1, v123, v12.0.1
                                                                                                • jiraShowReleased : String
                                                                                                • jiraShowArchived : String
                                                                                                • description : String (optional)
                                                                                              • jsonEditor
                                                                                                • name : String
                                                                                                  The name of the JsonEditor parameter. This name must be unique within a set of parameters added to a single choice (InputStep). The name must start with a Latin alphabet character and may contain 1-63 more Latin alphabet characters, Latin digits, hyphens ('-'), or underscores ('_').
                                                                                                • description : String (optional)
                                                                                                  The description for the JsonEditor parameter.
                                                                                                • options : String (optional)
                                                                                                  Extra options for the JsonEditor form. See options for details.
                                                                                                • schema : String (optional)
                                                                                                  The scheme for the JsonEditor form. See json-schema-support for details.
                                                                                                • startval : String (optional)
                                                                                                  The initial values for the JsonEditor form. This value should be valid against the schema.
                                                                                                  Leave empty to use the defaults from the schema.
                                                                                              • $class: 'LabelParameterDefinition'
                                                                                                • name : String
                                                                                                • defaultValue : String
                                                                                                • allNodesMatchingLabel : boolean
                                                                                                • nodeEligibility
                                                                                                  Defines how selected offline nodes should be handled.
                                                                                                  • All Nodes - trigger the job on all selected nodes, regardless of their online/offline state
                                                                                                  • Ignore Offline Nodes - trigger the job only on nodes being online and having an executor
                                                                                                  • Ignore Temp Offline Nodes - trigger the job on all selected nodes except on the ones currently manually marked as offline
                                                                                                    Nested Choice of Objects
                                                                                                  • $class: 'AllNodeEligibility'
                                                                                                    • $class: 'IgnoreOfflineNodeEligibility'
                                                                                                      • $class: 'IgnoreTempOfflineNodeEligibility'
                                                                                                      • triggerIfResult : String
                                                                                                      • description : String (optional)
                                                                                                    • listGitBranches

                                                                                                      When used, this parameter will display a field at build-time so that user is able to select a git branch or tag as a parameter for parametrized build..

                                                                                                      Note that this plugin is specifically designed for pipeline jobs that do not configure SCM but still want to see remote repository branches or tags before build begins.

                                                                                                      The plugin is highly motivated by Git Parameter Plugin.

                                                                                                      But unlike Git Parameter Plugin, this plugin will not change working space at all at build-time

                                                                                                      • name : String
                                                                                                        The name of the parameter.
                                                                                                      • remoteURL : String
                                                                                                        Specify the Git repository URL.
                                                                                                      • credentialsId : String
                                                                                                      • defaultValue : String
                                                                                                        This value is returned when list is empty.
                                                                                                      • sortMode
                                                                                                        Select how to sort the downloaded parameters. Only applies to a branch or a tag.
                                                                                                        • none
                                                                                                        • ascending smart
                                                                                                        • descending smart
                                                                                                        • ascending
                                                                                                        • descending
                                                                                                        When smart sorting is chosen, the compare treats a sequence of digits as a single character.
                                                                                                        • Values: NONE, ASCENDING_SMART, DESCENDING_SMART, ASCENDING, DESCENDING
                                                                                                      • selectedValue
                                                                                                        When this option is enabled will show a text field.
                                                                                                        Parameter is filtered on the fly.
                                                                                                        • Values: NONE, TOP, DEFAULT
                                                                                                      • quickFilterEnabled : boolean
                                                                                                        When this option is enabled will show a text field.
                                                                                                        Parameter is filtered on the fly.
                                                                                                      • type : String
                                                                                                        The type of the list of parameters:
                                                                                                        • Tag - list of all commit tags in repository - returns Tag Name
                                                                                                        • Branch - list of all branch in repository - returns Branch Name
                                                                                                      • tagFilter : String
                                                                                                        This parameter is used to get tag from git.
                                                                                                        If is blank, parameter is set to "*".
                                                                                                        Properly is executed command: git tag -l "*" or git tag -l "$tagFilter".
                                                                                                      • branchFilter : String
                                                                                                        Specify a regular expression which will be used to filter the branches which are actually displayed when triggering a new build.
                                                                                                      • listSize : String
                                                                                                        Specify the number of items the list will display. A value of 0 will display as a DropDown list.
                                                                                                      • description : String (optional)
                                                                                                    • $class: 'ListSubversionTagsParameterDefinition'
                                                                                                      When used, this parameter will display a field at build-time so that the user is able to select a Subversion tag from which to create the working copy for this project.

                                                                                                      Once the two fields Name and Repository URL are set, you must

                                                                                                      1. ensure the job uses Subversion and
                                                                                                      2. set the Repository URL field of Subversion by concatenating the two fields of this parameter.
                                                                                                      For instance, if Name is set to SVN_TAG and Repository URL is set to https://svn.jenkins-ci.org/tags, then Subversion's Repository URL must be set to https://svn.jenkins-ci.org/tags/$SVN_TAG.

                                                                                                      Notice that you can set the Repository URL field to a Subversion repository root rather than just pointing to a tags dir (ie, you can set it to https://svn.jenkins-ci.org rather than https://svn.jenkins-ci.org/tags). In that case, if this repository root contains the trunk, branches and tags folders, then the dropdown will allow the user to pick the trunk, or a branch, or a tag.

                                                                                                      • name : String
                                                                                                      • tagsDir : String
                                                                                                        Specify the Subversion repository URL which contains the tags to be listed when triggering a new build.

                                                                                                        You can also specify the root of a Subversion repository: If this root contains the trunk, branches and tags folders, then the dropdown will display trunk, all the branches and all the tags. If the root does not contain these three folders, then all its subfolders are listed in the dropdown.

                                                                                                        When you enter the URL, Jenkins automatically checks if it can connect to it. If access requires authentication, you'll be prompted for the necessary credential. If you already have a working credential but would like to change it for some other reasons, you can manage credentials and specify a different credential.

                                                                                                      • credentialsId : String
                                                                                                      • tagsFilter : String
                                                                                                        Specify a regular expression which will be used to filter the tags which are actually displayed when triggering a new build.
                                                                                                      • defaultValue : String
                                                                                                        For features such as SVN polling a default value is required. If job will only be started manually, this field is not necessary.
                                                                                                      • maxTags : String
                                                                                                        The maximum number of tags to display in the dropdown. Any non-number value will default to all.
                                                                                                      • reverseByDate : boolean
                                                                                                        Check this option so that tags are sorted from the newest to the oldest.

                                                                                                        If this option is checked, the Sort Z to A one won't be taken into account.

                                                                                                      • reverseByName : boolean
                                                                                                        Check this option so that tags are displayed in reverse order (sorted Z to A).

                                                                                                        Notice that if Sort newest first is checked, this option won't be taken into account.

                                                                                                      • description : String (optional)
                                                                                                    • $class: 'MatrixCombinationsParameterDefinition'
                                                                                                      • name : String
                                                                                                      • defaultCombinationFilter : String

                                                                                                        A Groovy expression to specify which combinations are checked by default. They are also combinations which is built in a scheduled build. If not specified, the combination filter of this multi-configuration project is used. Also see help of the combination filter.

                                                                                                        Note that you cannot enable combinations which disabled by the combination filter of the project.

                                                                                                      • shortcutList
                                                                                                        Links to check a set of combinations. Combinations to check are calculated with the last build in the build page or with the build to rebuild in the rebuild page (when Rebuild plugin is installed).
                                                                                                          Array / List of Nested Choice of Objects
                                                                                                        • $class: 'All'
                                                                                                          Check all enable combinations.
                                                                                                          • $class: 'CombinationFilterShortcut'
                                                                                                            Decide combinations to check with a combinations filter.
                                                                                                            • name : String
                                                                                                              The name displayed as the shortcut link.
                                                                                                            • combinationFilter : String
                                                                                                              A Groovy expression to decide combinations to check.
                                                                                                          • $class: 'None'
                                                                                                            Uncheck all combinations.
                                                                                                            • $class: 'PreviousShortcut'
                                                                                                              Check combinations built in the previous build.
                                                                                                              • $class: 'ResultShortcut'
                                                                                                                Check combinations with specific results in the previous build.
                                                                                                                • name : String
                                                                                                                  The name displayed as the shortcut link.
                                                                                                                • exact : boolean
                                                                                                                  Only checks child builds running exactly in the previous build.
                                                                                                                • resultsToCheck : Array / List of String
                                                                                                                  Results of child builds to check.
                                                                                                              • description : String (optional)
                                                                                                            • mavenMetadataVersions
                                                                                                              This parameter allows the resolution of maven artifact versions by contacting the repository and reading the maven-metadata.xml.

                                                                                                              If you named your parameter "MY_JAR" and have configured all values correctly. Then the following parameters will be set for the build step:
                                                                                                              • MY_JAR_VERSION - the version you selected in the dropdown or that was selected as part of an automated build
                                                                                                              • MY_JAR_ARTIFACT_URL - the full URL to the actual artifact selected. You can use something like "wget" to download that artifact and do something with it.
                                                                                                              • MY_JAR_GROUP_ID - echoes back your configuration
                                                                                                              • MY_JAR_ARTIFACT_ID - echoes back your configuration
                                                                                                              • MY_JAR_CLASSIFIER - echoes back your configuration
                                                                                                              • MY_JAR_PACKAGING - echoes back your configuration
                                                                                                              • name : String
                                                                                                              • repoBaseUrl : String
                                                                                                              • groupId : String
                                                                                                              • artifactId : String
                                                                                                              • packaging : String
                                                                                                              • classifier : String
                                                                                                              • versionFilter : String
                                                                                                                Specify a regular expression which will be used to filter the versions which are actually displayed when triggering a new build.
                                                                                                              • sortOrder : String
                                                                                                              • defaultValue : String
                                                                                                                For features such as SVN polling a default value is required. If job will only be started manually, this field is not necessary.
                                                                                                                There are 4 special default values which will be evaluated at runtime:
                                                                                                                • FIRST - will evaluate to the first item in the drop-down that would have been presented had the build been executed manually.
                                                                                                                • LAST - will evaluate to the last item in the drop-down that would have been presented had the build been executed manually.
                                                                                                                • RELEASE - will evaluate to the version marked as RELEASE in the repository metadata for the configured artifact. The versionFilter even if defined is ignored for this default value.
                                                                                                                • LATEST - will evaluate to the version marked as LATEST in the repository metadata for the configured artifact. The versionFilter even if defined is ignored for this default value.
                                                                                                              • maxVersions : String
                                                                                                                The maximum number of versions to display in the drop-down. Any non-number value as well as 0 or negative values will default to all.
                                                                                                              • currentArtifactInfoUrl : String
                                                                                                                The URL where an information resource about the currently used artifact can be requested. If the URL is provided and valid, the information will be displayed next to the drop-down. Otherwise not artifact information will be displayed.
                                                                                                              • currentArtifactInfoLabel : String
                                                                                                                An informational label that will be displayed in front of the aritfact information. When no label is specified, the default label Currently used artifact will be displayed. Any label will only be displayed when a valid Current Artifact Info URL is configured.
                                                                                                              • currentArtifactInfoPattern : String
                                                                                                                A pattern that describes the part of the artifact information resources' content to be displayed:
                                                                                                                  When no pattern is specified, the whole content will be displayed.
                                                                                                                  When a standard pattern is specified, only its first match in the content will be displayed.
                                                                                                                  When a pattern with a capturing group is specified, only the first group of its first match in the content will be displayed.
                                                                                                              • credentialsId : String
                                                                                                              • description : String (optional)
                                                                                                            • multiselect
                                                                                                              • name : String
                                                                                                                Name of the parameter displayed in forms.
                                                                                                              • description : String (optional)
                                                                                                                Description that is displayed as a help for users running a parameterized build, as to what the parameter is used for.
                                                                                                              • decisionTree (optional)
                                                                                                                  Nested Object
                                                                                                                • itemList (optional)
                                                                                                                    Array / List of Nested Object
                                                                                                                  • label : String (optional)
                                                                                                                  • value : String (optional)
                                                                                                                  • children (optional)
                                                                                                                      Array / List of Nested Object
                                                                                                                • variableDescriptions (optional)
                                                                                                                    Array / List of Nested Object
                                                                                                                  • label : String (optional)
                                                                                                                  • variableName : String (optional)
                                                                                                              • format (optional)
                                                                                                                • Values: CSV
                                                                                                            • $class: 'NetstormTestParameterDefinition'
                                                                                                              • name : String
                                                                                                              • keyword : String
                                                                                                              • description : String (optional)
                                                                                                            • $class: 'NodeParameterDefinition'
                                                                                                              • name : String
                                                                                                              • defaultSlaves : Array / List of String
                                                                                                                • allowedSlaves : Array / List of String
                                                                                                                  • triggerIfResult : String
                                                                                                                  • nodeEligibility
                                                                                                                    Defines how selected offline nodes should be handled.
                                                                                                                    • All Nodes - trigger the job on all selected nodes, regardless of their online/offline state
                                                                                                                    • Ignore Offline Nodes - trigger the job only on nodes being online and having an executor
                                                                                                                    • Ignore Temp Offline Nodes - trigger the job on all selected nodes except on the ones currently manually marked as offline
                                                                                                                      Nested Choice of Objects
                                                                                                                    • $class: 'AllNodeEligibility'
                                                                                                                      • $class: 'IgnoreOfflineNodeEligibility'
                                                                                                                        • $class: 'IgnoreTempOfflineNodeEligibility'
                                                                                                                        • description : String (optional)
                                                                                                                      • ontrackChoiceParam

                                                                                                                        Gets a list of parameter value to choose from, using the execution of a Ontrack DSL script.

                                                                                                                        The script is expected to return a list of objects (a single object will be converted into a singleton list) and the parameter value of each item will be extracted from this object using the property defined in the Value property field.

                                                                                                                        • name : String
                                                                                                                        • dsl : String
                                                                                                                        • sandbox : boolean
                                                                                                                        • valueProperty : String
                                                                                                                        • injectProperties : String
                                                                                                                        • description : String (optional)
                                                                                                                      • ontrackMultiChoiceParam

                                                                                                                        Gets a list of parameter value to choose from, using the execution of a Ontrack DSL script.

                                                                                                                        The script is expected to return a list of objects (a single object will be converted into a singleton list) and the parameter value of each item will be extracted from this object using the property defined in the Value property field.

                                                                                                                        • name : String
                                                                                                                        • dsl : String
                                                                                                                        • sandbox : boolean
                                                                                                                        • valueProperty : String
                                                                                                                        • injectProperties : String
                                                                                                                        • description : String (optional)
                                                                                                                      • ontrackSingleParam

                                                                                                                        Gets a parameter value from the execution of a Ontrack DSL script.

                                                                                                                        The script is expected to return a single object and the value of the parameter will be extracted from this object using the property defined in the Value property field.

                                                                                                                        • name : String
                                                                                                                        • dsl : String
                                                                                                                        • sandbox : boolean
                                                                                                                        • valueProperty : String
                                                                                                                        • injectProperties : String
                                                                                                                        • description : String (optional)
                                                                                                                      • $class: 'PackageChoiceParameterDefinition'
                                                                                                                        List Content Packages available for download from a configured Adobe CRX repository.
                                                                                                                        • name : String
                                                                                                                        • baseUrl : String
                                                                                                                          Specify the base URL of the Adobe Granite server, including hostname and port. The CRX Package Manager service path will be appended to this value for all requests. For example, http://localhost:4502 or https://author.mycorp.com, etc.

                                                                                                                          If login credentials for the server are different than those configured in the Connection Options section, you may override them in the Base URL by inserting username[:password]@ between the scheme and the hostname.

                                                                                                                          For example, to override the Username without changing the associated password or private key, you may use the following form:

                                                                                                                          http://deployer@localhost:4502

                                                                                                                          To override the credentials completely, provide a username and password (which may be provided by an encrypted parameter) by separating them with a colon, as shown below:

                                                                                                                          http://deployer:Password123@localhost:4502
                                                                                                                        • credentialsId : String
                                                                                                                          Select the login credentials with which content packages will be listed from the CRX server.

                                                                                                                          [Signature] credentials may be used if the target server supports HTTP Signature Authentication using the keyId format, /$username/keys/$fingerprint.

                                                                                                                          Select "-none-" to use the default credentials set in the global CRX Content Package Deployer - HTTP Client configuration.
                                                                                                                        • requestTimeout : long
                                                                                                                          Specify the timeout in milliseconds to wait for a response for each individual request. Specify a value of 0 to use default behavior.
                                                                                                                        • serviceTimeout : long
                                                                                                                          Specify the timeout in milliseconds to wait for PackageManager service availability between sending POST requests. Specify a value of 0 to use default behavior.
                                                                                                                        • multiselect : boolean
                                                                                                                        • excludeNotInstalled : boolean
                                                                                                                          Filter the list to exclude packages which have been uploaded to the server, but which are not installed.
                                                                                                                        • excludeModified : boolean
                                                                                                                          Filter the list to exclude packages whose metadata have been modified after upload to the server, e.g. which need to be re-wrapped.
                                                                                                                        • visibleItemCount : long
                                                                                                                          Set the number of visible items displayed when multiselect is enabled. The default is 10.
                                                                                                                        • query : String
                                                                                                                          Specify a full-text search query to filter the list of packages, such as "Adobe".
                                                                                                                        • packageIdFilter : String
                                                                                                                          Specify a package ID filter to match against the list of packages returned from the configured Granite server.

                                                                                                                          A Package ID consists of the group, the name, and the version of a package, separated by colons (':').

                                                                                                                          Package ID filters must follow one of three patterns:
                                                                                                                          • group:name:version
                                                                                                                          • group:name
                                                                                                                          • name
                                                                                                                          Each segment in the filter may be either ommitted or replaced with an asterisk ('*') to represent a wildcard.
                                                                                                                        • value : String
                                                                                                                        • description : String (optional)
                                                                                                                      • $class: 'PackageParameterDefinition'
                                                                                                                        • name : String
                                                                                                                        • rep : String
                                                                                                                        • pkg : String
                                                                                                                        • description : String (optional)
                                                                                                                      • separator
                                                                                                                        Inserts a visual separator for build parameters: horizontal rule (<hr/> element) with an optional "Section Header" below it.
                                                                                                                        • name : String
                                                                                                                        • separatorStyle : String
                                                                                                                          Defines a custom CSS style for the Separator (i.e. the <hr/> tag). If empty, "Global separator style" is used, as configured by an administrator in Jenkins global configuaration.
                                                                                                                        • sectionHeader : String
                                                                                                                          Inserts a section header below the horizontal rule. Can be empty.
                                                                                                                        • sectionHeaderStyle : String
                                                                                                                          Defines a custom CSS style for the Section Header. If empty, "Global section header style" is used, as configured by an administrator in Jenkins global configuaration.
                                                                                                                        • description : String (optional)
                                                                                                                      • $class: 'PatchParameterDefinition'
                                                                                                                        Accepts a patch file to be submitted. This patch will be applied to the workspace after the source code is checked out, then the build will proceed.
                                                                                                                        • description : String (optional)
                                                                                                                      • persistentBoolean
                                                                                                                        • name : String
                                                                                                                        • defaultValue : boolean
                                                                                                                        • successfulOnly : boolean
                                                                                                                        • description : String (optional)
                                                                                                                      • persistentChoice
                                                                                                                        • name : String
                                                                                                                        • description : String (optional)
                                                                                                                        • choices : Object (optional)
                                                                                                                        • successfulOnly : boolean (optional)
                                                                                                                      • $class: 'PersistentPackageParameterDefinition'
                                                                                                                        • name : String
                                                                                                                        • useAwsKeys : boolean

                                                                                                                          If you need to access the repository outside of the repository, you will need grant access to the S3 bucket.

                                                                                                                          When accessing it from within AWS, it's probable that the server itself provides the necessary access rights.

                                                                                                                          When accessing it from outside, you need to provide a key pair. These are set up in the AWS admin console. If you don't have access, please ask operations to create a new key pair with access to the specified bucket.

                                                                                                                        • awsAccessKeyId : String

                                                                                                                          This is the AWS secret key setup in the AWS console. It will resemble the form: ‘AAAAAAAAAA2AAA2AAAAA

                                                                                                                          If you don't have access to the AWS console, and you need an access key pair, please contact someone in operations.

                                                                                                                        • awsSecretAccessKey : String

                                                                                                                          This is the AWS secret key setup in the AWS console. It will resemble the form: ‘XxXXXxx/1ZZz1zZZZ11zzZ1zz/YyYyYyyYyyyyYY

                                                                                                                          If you don't have access to the AWS console, and you need an access key pair, please contact someone in operations.

                                                                                                                        • bucketName : String

                                                                                                                          This should be set to a valid bucket name that you can access using the key value pair, or if within AWS, that the server has access to.

                                                                                                                          Ensure that the bucket specified contains the repo. It might sound obvious, but I just wanted to point that out.

                                                                                                                        • repoPath : String

                                                                                                                          This is the path to the actual repo containing the artifacts, relative to the AWS S3 bucket.

                                                                                                                          For example, given the S3 bucket ‘vhols-common-test-yumrepo’, the path to the locations-public-api repo is repos/locations-public-api

                                                                                                                        • repositoryType : String
                                                                                                                        • description : String (optional)
                                                                                                                      • persistentString
                                                                                                                        • name : String
                                                                                                                        • defaultValue : String
                                                                                                                        • successfulOnly : boolean
                                                                                                                        • trim : boolean
                                                                                                                          Strip whitespace from the beginning and end of the string.
                                                                                                                        • description : String (optional)
                                                                                                                      • persistentText
                                                                                                                        • name : String
                                                                                                                        • defaultValue : String
                                                                                                                        • successfulOnly : boolean
                                                                                                                        • description : String (optional)
                                                                                                                      • $class: 'PersistentYumParameterDefinition'
                                                                                                                        • name : String
                                                                                                                        • useAwsKeys : boolean

                                                                                                                          If you need to access the repository outside of the repository, you will need grant access to the S3 bucket.

                                                                                                                          When accessing it from within AWS, it's probable that the server itself provides the necessary access rights.

                                                                                                                          When accessing it from outside, you need to provide a key pair. These are set up in the AWS admin console. If you don't have access, please ask operations to create a new key pair with access to the specified bucket.

                                                                                                                        • awsAccessKeyId : String

                                                                                                                          This is the AWS secret key setup in the AWS console. It will resemble the form: ‘AAAAAAAAAA2AAA2AAAAA

                                                                                                                          If you don't have access to the AWS console, and you need an access key pair, please contact someone in operations.

                                                                                                                        • awsSecretAccessKey : String

                                                                                                                          This is the AWS secret key setup in the AWS console. It will resemble the form: ‘XxXXXxx/1ZZz1zZZZ11zzZ1zz/YyYyYyyYyyyyYY

                                                                                                                          If you don't have access to the AWS console, and you need an access key pair, please contact someone in operations.

                                                                                                                        • bucketName : String

                                                                                                                          This should be set to a valid bucket name that you can access using the key value pair, or if within AWS, that the server has access to.

                                                                                                                          Ensure that the bucket specified contains the repo. It might sound obvious, but I just wanted to point that out.

                                                                                                                        • repoPath : String

                                                                                                                          This is the path to the actual repo containing the artifacts, relative to the AWS S3 bucket.

                                                                                                                          For example, given the S3 bucket ‘vhols-common-test-yumrepo’, the path to the locations-public-api repo is repos/locations-public-api

                                                                                                                        • description : String (optional)
                                                                                                                      • $class: 'PromotedBuildParameterDefinition'
                                                                                                                        • name : String
                                                                                                                        • jobName : String
                                                                                                                        • process : String
                                                                                                                        • description : String (optional)
                                                                                                                      • $class: 'PromotionLevelParameter'
                                                                                                                        Defines a parameter selected from the configured promotion levels. Note that the parameter provided to builds has the numeric value of the promotion level, i.e. its index in the list below, starting with one.
                                                                                                                        If used with the Copy Artifact plugin to copy artifacts of a particular promotion level, the name of the parameter should be COPY_PROMOTION_LEVEL.
                                                                                                                        • name : String
                                                                                                                        • defaultLevel : int
                                                                                                                        • description : String (optional)
                                                                                                                      • $class: 'RandomStringParameterDefinition'
                                                                                                                        • name : String
                                                                                                                        • failedValidationMessage : String
                                                                                                                        • description : String (optional)
                                                                                                                      • RESTList
                                                                                                                        • name : String
                                                                                                                          The name of the parameter
                                                                                                                          These parameters are exposed to build as environment variables.
                                                                                                                        • restEndpoint : String
                                                                                                                          The URL address for to the REST endpoint.

                                                                                                                          e.g. List GitLab repository releases https://gitlab.example.com/api/v4/projects/:id/releases
                                                                                                                        • credentialId : String
                                                                                                                          Depending on the authentication requirement for the REST/Web endpoint there are three supported methods:
                                                                                                                          • `NONE` if there is no authentication requirement simply don't select any _Credential ID_
                                                                                                                          • `BASIC` if this authentication type is required, then simply select any Username and Password credential in the _Credential ID_ field
                                                                                                                          • `BEARER` if this authentication type is required, then simply select any Secret Text credential in the _Credential ID_ field
                                                                                                                          NOTE: The Authentication header will be build and added based on the type of the selected credential type.
                                                                                                                        • mimeType
                                                                                                                          The MIME type that gets requested from the REST endpoint (i.e. Accepts: application/json)

                                                                                                                          NOTE This setting also define which kind of Value Expression gets applied to select the values in the end.
                                                                                                                          • APPLICATION_JSON - Json-Path syntax is expected in the Value Expression
                                                                                                                          • APPLICATION_XML - xPath syntax is expected in the Value Expression
                                                                                                                          • Values: APPLICATION_JSON, APPLICATION_XML
                                                                                                                        • valueExpression : String
                                                                                                                          The Value Expression dictates how the values get pares out of the REST response.
                                                                                                                          Depending on the selected MIME type the syntax expects is either Json-Path or xPath:
                                                                                                                        • description : String (optional)
                                                                                                                          A description that will be shown to the user later.
                                                                                                                        • displayExpression : String (optional)
                                                                                                                          The Display Expression dictates how the values get displayed based on the object parsed from value expression.
                                                                                                                          Depending on the selected MIME type the syntax expects is either Json-Path or xPath:
                                                                                                                        • cacheTime : int (optional)
                                                                                                                          Allows the user to cache values returned from a HTTP endpoint.
                                                                                                                          The unit of this value is MINUTES. If the value is set to 0, a web request is forced.
                                                                                                                          NOTE: The cache can globally hold up to 50 MiB per default, which should be enough for most use-cases.
                                                                                                                          (The maximum size of the cache can be adjusted in the global Jenkins settings)
                                                                                                                        • defaultValue : String (optional)
                                                                                                                          The Default Value allows the user to predetermine the value selected for this parameter.
                                                                                                                          NOTE This has to be the exact same value as the value to be preselected, because it gets string compared.
                                                                                                                        • filter : String (optional)
                                                                                                                          A simple regex filter applied on the values list generated by the Value Expression
                                                                                                                          This filter is useful for longer value lists (e.g. version lists) to filter for only relevant values.
                                                                                                                        • valueOrder (optional)
                                                                                                                          This setting provides tha ability to sort the received values from the endpoint set above.
                                                                                                                          Can be useful if your endpoint returns a lot of values and does not return them in order nor provides the option to.
                                                                                                                          • NONE - Do not apply any post ordering on the received values
                                                                                                                          • ASC - "Ascending" order gets applied on the received values
                                                                                                                          • DSC - "Descending" order gets applied on the received values
                                                                                                                          • Values: NONE, ASC, DSC, REV
                                                                                                                      • $class: 'ReviewboardParameterDefinition'
                                                                                                                        Accepts a patch url or number of review request. This patch will be applied to the workspace after the source code is checked out, then the build will proceed.
                                                                                                                        • defaultValue : String (optional)
                                                                                                                        • description : String (optional)
                                                                                                                        • trim : boolean (optional)
                                                                                                                          Strip whitespace from the beginning and end of the string.
                                                                                                                      • $class: 'RunFilterParameter'
                                                                                                                      • run
                                                                                                                        • name : String
                                                                                                                        • projectName : String
                                                                                                                        • filter
                                                                                                                          • Values: ALL, STABLE, SUCCESSFUL, COMPLETED
                                                                                                                        • description : String (optional)
                                                                                                                      • $class: 'RunSelectorParameter'
                                                                                                                      • $class: 'SauceParameterDefinition'
                                                                                                                        • description : String (optional)
                                                                                                                      • $class: 'ScriptSelectionTaskDefinition'
                                                                                                                        • name : String
                                                                                                                        • path : String
                                                                                                                        • arrayCheckBox
                                                                                                                            Array / List of Nested Object
                                                                                                                          • name : String
                                                                                                                          • variableName : String
                                                                                                                          • check : boolean
                                                                                                                          • type : String
                                                                                                                          • parent : String
                                                                                                                        • testDelimSymbol : String
                                                                                                                        • nodeDelimSymbol : String
                                                                                                                        • countDelimiterSymbol : int
                                                                                                                        • delimiter : String
                                                                                                                        • defaultValue : String
                                                                                                                        • description : String (optional)
                                                                                                                      • snParam
                                                                                                                        • credentialsForPublishedApp : String
                                                                                                                          User name and password defined in global credentials (credentials ID is required here) used for the instance where the application will be published.
                                                                                                                        • instanceForPublishedAppUrl : String
                                                                                                                          ServiceNow instance url where the application will be published to.
                                                                                                                        • credentialsForInstalledApp : String
                                                                                                                          User name and password defined in global credentials (credentials ID is required here) used for the instance where the application will be installed.
                                                                                                                        • instanceForInstalledAppUrl : String
                                                                                                                          ServiceNow instance url where the application will be installed.
                                                                                                                        • sysId : String
                                                                                                                          Required if application scope is not specified. The system id of the application for which to apply the changes. You can locate this value in the Sys ID field in the Custom Application [sys_app] table.
                                                                                                                        • appScope : String
                                                                                                                          Required if application system ID is not specified. The scope name of the application for which to apply the changes, such as x_aah_custom_app. You can locate this value in the scope field in the Custom Application [sys_app] table.
                                                                                                                        • publishedAppVersion : String
                                                                                                                          Version number of published application (that will be also installed if appropriate build step will be used). Do not fill the field up if you want to get the number automatically (depends on the build step 'Publish application').
                                                                                                                        • rollbackAppVersion : String
                                                                                                                          Version number of the application used by the step 'Roll back application'.
                                                                                                                          Do not fill this field up if the version should be obtained automatically.
                                                                                                                        • batchRollbackId : String
                                                                                                                        • progressCheckInterval : int
                                                                                                                          Time in milliseconds between one and another progress check set up for all build steps of ServiceNow.
                                                                                                                          Leave it empty to use default value.
                                                                                                                        • description : String (optional)
                                                                                                                      • $class: 'SpringBootLibrariesListParameterDefinition'
                                                                                                                        • springBootVersion : String
                                                                                                                        • defaultValue : String (optional)
                                                                                                                        • description : String (optional)
                                                                                                                        • trim : boolean (optional)
                                                                                                                          Strip whitespace from the beginning and end of the string.
                                                                                                                      • $class: 'StashBranchParameterDefinition'
                                                                                                                        • name : String
                                                                                                                          The name of the parameter.
                                                                                                                        • repository : String
                                                                                                                        • defaultValue : String
                                                                                                                        • description : String (optional)
                                                                                                                        • branchNameRegex : String (optional)
                                                                                                                        • tagNameRegex : String (optional)
                                                                                                                      • stashedFile

                                                                                                                        File parameter compatible with Pipeline but using the stash system, better suited to large files. The file will be saved to a stash named like the parameter containing one entry, also named like the parameter. Example usage from Declarative Pipeline:

                                                                                                                        pipeline {
                                                                                                                          agent any
                                                                                                                          parameters {
                                                                                                                            stashedFile 'assets.zip'
                                                                                                                          }
                                                                                                                          stages {
                                                                                                                            stage('Example') {
                                                                                                                              steps {
                                                                                                                                unstash 'assets.zip'
                                                                                                                                sh 'unzip assets.zip'
                                                                                                                              }
                                                                                                                            }
                                                                                                                          }
                                                                                                                        }
                                                                                                                         
                                                                                                                        • name : String

                                                                                                                          The name of the parameter. Depending on the type of parameter, this may or may not be bound as an environment variable during the build.

                                                                                                                          If a local filename was given, an environment variable paramname_FILENAME will also be set. If the build is triggered via the CLI, the variable will not be set.

                                                                                                                        • description : String (optional)
                                                                                                                      • string
                                                                                                                        • name : String
                                                                                                                        • defaultValue : String (optional)
                                                                                                                        • description : String (optional)
                                                                                                                        • trim : boolean (optional)
                                                                                                                          Strip whitespace from the beginning and end of the string.
                                                                                                                      • $class: 'TestExecuter'
                                                                                                                        This plugin allows you to choose specific tests you want to run.
                                                                                                                        First, you need to specify the name of the environment variable in which you want your selected tests to be saved in (after build the selected tests will be in this environment variable as a JSON array).
                                                                                                                        Second, you need to enter the properties file path. This file will contain all your tests and maybe some extra fields for the plugin (more details about the properties file are in the appropriate help field).
                                                                                                                        After that, your tests will be shown in a tree diagram, allowing you to select some of them.
                                                                                                                        • name : String
                                                                                                                          Enter the name of the environment variable in which you want your selected tests to be saved in (after build the selected tests will be in this environment variable as a JSON array).
                                                                                                                        • propertiesFilePath : String
                                                                                                                          The properties file you enter must have a property called tests.
                                                                                                                          The tests property value is a JSON array that contains a JSON object for each test.
                                                                                                                          In each test object you need to specify it's attributes by a key/value pairs.

                                                                                                                          The following properties will allow you to select specific fields which have a special meaning:
                                                                                                                          1.  enableField - the name of the field that will imply if the test is enabled or not.
                                                                                                                          if the value in the specified field, for some test(s), will be false then the test will not be shown at all.
                                                                                                                          2.  groupBy - the field that the plugin will group the tests by.
                                                                                                                          if 2 tests have the same value in this field, they will be in the same group.
                                                                                                                          3.  showFields - the field(s) that will be shown in the tests tree.
                                                                                                                          4.  multiplicityField - the field that will be set to the amount of times the test should run.
                                                                                                                          5.  fieldSeparator - the character that will separate between the fields in the tests tree.
                                                                                                                          Each property must be defined either in the properties file or in the override section bellow.
                                                                                                                          If you want to change the properties you defined In the file, you can override them in the section bellow.

                                                                                                                          This is an example for a properties file which contains all above properties:
                                                                                                                          tests=[{"enabled":true,"owner":"shushu","testgroup":"A","testcase":"single"},{"enabled":false,"owner":"shushu","testgroup":"B","setuptype":"basic","testcase":"triple"}]
                                                                                                                          enableField=enabled
                                                                                                                          groupBy=testgroup
                                                                                                                          fieldSeparator=.
                                                                                                                          showFields=testsuite,testcase
                                                                                                                          multiplicityField=multiplicity
                                                                                                                        • enableField
                                                                                                                          Setting Enable Field property.
                                                                                                                          Enable Field - the name of the field that will imply if the test is enabled or not. If the value in the specified field, for some test(s), will be false then the test will not be shown at all.
                                                                                                                            Nested Object
                                                                                                                          • text : String
                                                                                                                        • groupBy
                                                                                                                          Setting Group By property.
                                                                                                                          Group By - the field that the plugin will group the tests by. If 2 tests have the same value in this field, they will be in the same group.
                                                                                                                            Nested Object
                                                                                                                          • text : String
                                                                                                                        • fieldSeparator
                                                                                                                          Setting Field Separator property.
                                                                                                                          Field Separator - the character that will separate between the fields in the tests tree.
                                                                                                                            Nested Object
                                                                                                                          • text : String
                                                                                                                        • showFields
                                                                                                                          Setting Show Fields property.
                                                                                                                          Show Fields - the field(s) that will be shown in the tests tree.
                                                                                                                          If you click on "Show/Hide Available Fields" button then next to each available field appears (howManyTestsHasThisField/amountOfTests).
                                                                                                                            Nested Object
                                                                                                                          • text : String
                                                                                                                        • multiplicityField
                                                                                                                          Setting Multiplicity Field property.
                                                                                                                          Multiplicity Field - the field that will be set to the amount of times the test should run.
                                                                                                                            Nested Object
                                                                                                                          • text : String
                                                                                                                        • description : String (optional)
                                                                                                                      • text
                                                                                                                        • name : String
                                                                                                                        • defaultValue : String (optional)
                                                                                                                        • description : String (optional)
                                                                                                                        • trim : boolean (optional)
                                                                                                                          Strip whitespace from the beginning and end of the string.
                                                                                                                      • $class: 'ToolVersionParameterDefinition'
                                                                                                                        • toolName : String
                                                                                                                        • description : String (optional)
                                                                                                                      • $class: 'VBoxParameterDefinition'
                                                                                                                        Build parameter with virtual node names. Parameter name is exported to the build from virtual node names joined by node name delimiter.
                                                                                                                        • name : String
                                                                                                                        • nodeDelimiter : String
                                                                                                                        • description : String (optional)
                                                                                                                      • email
                                                                                                                        • name : String
                                                                                                                        • defaultValue : String
                                                                                                                        • domain : String
                                                                                                                        • externalEmail : boolean
                                                                                                                        • description : String (optional)
                                                                                                                      • validatingString
                                                                                                                        Defines a simple text parameter, where users can enter a string value, which you can use during a build, either as an environment variable, or through variable substitution in some other parts of the configuration.

                                                                                                                        Additionally, this parameter supports a regular expression based validation of the user entered parameter to ensure it meets the build's requirements.
                                                                                                                        • name : String
                                                                                                                          The name of the parameter

                                                                                                                          These parameters are exposed to build as environment variables.

                                                                                                                        • defaultValue : String
                                                                                                                          Specifies the default value of the field, which allows the user to save typing the actual value.
                                                                                                                        • regex : String

                                                                                                                          Standard Java regular expression that will be used to validate the entered string parameter value.

                                                                                                                        • failedValidationMessage : String

                                                                                                                          This message is displayed to the user if they enter a value that does not match the configured regular expression.

                                                                                                                        • description : String (optional)
                                                                                                                          A description that will be shown to the user later.
                                                                                                                      • validatingYamlParameter
                                                                                                                        • name : String
                                                                                                                        • defaultValue : String
                                                                                                                        • failedValidationMessage : String

                                                                                                                          This message is displayed to the user if they enter a value that is not a syntactical correct YAML

                                                                                                                        • description : String (optional)
                                                                                                                      • $class: 'VersionParameterDefinition'
                                                                                                                        Defines a build parameter for the selecting a version of the artifact to use at job runtime.
                                                                                                                        • name : String
                                                                                                                        • groupId : String
                                                                                                                        • artifactId : String
                                                                                                                        • description : String (optional)
                                                                                                                        • includeReleases : boolean (optional)
                                                                                                                        • includeSnapshots : boolean (optional)
                                                                                                                        • limit : String (optional)
                                                                                                                        • oldestFirst : boolean (optional)
                                                                                                                        • repositoryId : String (optional)
                                                                                                                        • useLatest : boolean (optional)
                                                                                                                        • useRelease : boolean (optional)
                                                                                                                      • hidden
                                                                                                                        • name : String
                                                                                                                        • defaultValue : String
                                                                                                                        • description : String (optional)
                                                                                                                      • $class: 'WReadonlyStringParameterDefinition'
                                                                                                                        • name : String
                                                                                                                        • defaultValue : String
                                                                                                                        • description : String (optional)
                                                                                                                      • $class: 'WReadonlyTextParameterDefinition'
                                                                                                                        • name : String
                                                                                                                        • defaultValue : String
                                                                                                                        • description : String (optional)
                                                                                                                      • extendedChoice

                                                                                                                        This parameter adds various types of choice fields to the Pipeline Input Step.

                                                                                                                        • name : String
                                                                                                                          The name of the parameter.
                                                                                                                        • type : String
                                                                                                                          The type of parameter:
                                                                                                                          • Single Select: user chooses a single selection from a drop down menu, populated by either explicit values (see Value field below) or a property file (see Property File and Property Key fields below)

                                                                                                                          • Multi Select: a user can choose multiple selections from a multi-line box, populated by either explicit values (see Value field below) or a property file (see Property File and Property Key fields below)

                                                                                                                          • Check Boxes: user can check off zero or more check boxes, labeled by either explicit values (see Value field below) or a property file (see Property File and Property Key fields below)

                                                                                                                          • Multi-Level Single Select: user chooses a selection from a drop down, and then a another drop down appears with selections that depend on the first value, and upon second selection a third drop down may appear depending on the first two selections, and so on.

                                                                                                                            The property file is a tab delimited file, with levels defined in columns and choices defined in rows. For example, to have a 2 level selection where you first select a country and then a city, you could specify a file such as the following:

                                                                                                                            Country	City
                                                                                                                            United States	San Francisco
                                                                                                                            United States	Chicago
                                                                                                                            Mexico	Mexico City
                                                                                                                            Mexico	Cancun
                                                                                                                                        
                                                                                                                            This would result in a first drop down with the options "Select a country...", "United States", and "Mexico" (the initial selection is "Select a country...", which serves as a label for the drop down). After the user selects a country, a "City" drop down would appear. If United States was chosen first, then San Francisco and Chicago would be options, but if Mexico was selected then instead Mexico City and Cancun would be options.

                                                                                                                            The columns that should represent levels must be specified in the value field. For example "Country,City" could be valid values.

                                                                                                                            Note that default values are not supported for multi-level selects.

                                                                                                                          • Multi-Level Multi Select: same as single select, but after all levels are chosen, a button appears to "Select another..." and an additional multi-level selection is presented.
                                                                                                                        • value : String
                                                                                                                          Comma separated list of values for the single select or multi-select box.

                                                                                                                          This field can be left blank if the comma separated values need to be picked up from a properties file (set via 'Property File' and 'Property Key').

                                                                                                                          This value has different meaning for multi-level select -- see the parameter type help for more info.
                                                                                                                        • projectName : String
                                                                                                                          If specified, this adds a currentProject entry to the groovy script context. The entry's value is set to the specified Jenkins project.
                                                                                                                        • propertyFile : String
                                                                                                                          The properties file is a collection of key,value pairs of the form key=value1,value2,...

                                                                                                                          Properties may reference other properties. For example:
                                                                                                                          prop1=a,b,c,d,e
                                                                                                                          prop2=${prop1},f,g,h
                                                                                                                          The properties file can be placed anywhere on the file-system that Jenkins can access.

                                                                                                                          This property file has different meaning for multi-level select -- see the parameter type help for more info.
                                                                                                                        • groovyScript : String
                                                                                                                        • groovyScriptFile : String
                                                                                                                        • bindings : String
                                                                                                                        • groovyClasspath : String
                                                                                                                        • propertyKey : String
                                                                                                                          The property of the property file to use.

                                                                                                                          For example, if the property file was the following:
                                                                                                                          prop1=a,b,c,d,e
                                                                                                                          prop2=1,2,3,4
                                                                                                                          Then you could specify the property as either prop1 or prop2.
                                                                                                                        • defaultValue : String
                                                                                                                          Initial selection of the single-select or mult-select box.

                                                                                                                          In case of the multi-select box, default value can be a comma separated string.
                                                                                                                        • defaultPropertyFile : String
                                                                                                                          Absolute path (specified without using environment variables).
                                                                                                                        • defaultGroovyScript : String
                                                                                                                        • defaultGroovyScriptFile : String
                                                                                                                        • defaultBindings : String
                                                                                                                        • defaultGroovyClasspath : String
                                                                                                                        • defaultPropertyKey : String
                                                                                                                        • descriptionPropertyValue : String
                                                                                                                        • descriptionPropertyFile : String
                                                                                                                        • descriptionGroovyScript : String
                                                                                                                        • descriptionGroovyScriptFile : String
                                                                                                                        • descriptionBindings : String
                                                                                                                        • descriptionGroovyClasspath : String
                                                                                                                        • descriptionPropertyKey : String
                                                                                                                        • javascriptFile : String
                                                                                                                        • javascript : String
                                                                                                                        • saveJSONParameterToFile : boolean
                                                                                                                        • quoteValue : boolean
                                                                                                                        • visibleItemCount : int
                                                                                                                        • multiSelectDelimiter : String

                                                                                                                          Inserts this value between selections when the parameter is a multi-select.

                                                                                                                          The default when empty is ','

                                                                                                                        • description : String (optional)
                                                                                                                      • $class: 'com.michelin.cio.hudson.plugins.passwordparam.PasswordParameterDefinition'
                                                                                                                        • name : String
                                                                                                                        • description : String (optional)
                                                                                                                      • $class: 'com.moded.extendedchoiceparameter.ExtendedChoiceParameterDefinition'
                                                                                                                        • name : String
                                                                                                                          The name of the parameter.
                                                                                                                        • type : String
                                                                                                                          The type of parameter:
                                                                                                                          • Single Select: user chooses a single selection from a drop down menu, populated by either explicit values (see Value field below) or a property file (see Property File and Property Key fields below)

                                                                                                                          • Multi Select: a user can choose multiple selections from a multi-line box, populated by either explicit values (see Value field below) or a property file (see Property File and Property Key fields below)

                                                                                                                          • Check Boxes: user can check off zero or more check boxes, labeled by either explicit values (see Value field below) or a property file (see Property File and Property Key fields below)

                                                                                                                          • Multi-Level Single Select: user chooses a selection from a drop down, and then a another drop down appears with selections that depend on the first value, and upon second selection a third drop down may appear depending on the first two selections, and so on.

                                                                                                                            The property file is a tab delimited file, with levels defined in columns and choices defined in rows. For example, to have a 2 level selection where you first select a country and then a city, you could specify a file such as the following:

                                                                                                                            Country	City
                                                                                                                            United States	San Francisco
                                                                                                                            United States	Chicago
                                                                                                                            Mexico	Mexico City
                                                                                                                            Mexico	Cancun
                                                                                                                                        
                                                                                                                            This would result in a first drop down with the options "Select a country...", "United States", and "Mexico" (the initial selection is "Select a country...", which serves as a label for the drop down). After the user selects a country, a "City" drop down would appear. If United States was chosen first, then San Francisco and Chicago would be options, but if Mexico was selected then instead Mexico City and Cancun would be options.

                                                                                                                            The columns that should represent levels must be specified in the value field. For example "Country,City" could be valid values.

                                                                                                                            Note that default values are not supported for multi-level selects.

                                                                                                                          • Multi-Level Multi Select: same as single select, but after all levels are chosen, a button appears to "Select another..." and an additional multi-level selection is presented.
                                                                                                                        • value : String
                                                                                                                          Comma separated list of values for the single select or multi-select box.

                                                                                                                          This field can be left blank if the comma separated values need to be picked up from a properties file (set via 'Property File' and 'Property Key').

                                                                                                                          This value has different meaning for multi-level select -- see the parameter type help for more info.
                                                                                                                        • propertyFile : String
                                                                                                                          The properties file is a collection of key,value pairs of the form key=value1,value2,...

                                                                                                                          Property files may reference other properties. For example:
                                                                                                                          prop1=a,b,c,d,e
                                                                                                                          prop2=${prop1},f,g,h
                                                                                                                          The properties file can be placed anywhere on the file-system that Jenkins can access.

                                                                                                                          This property file has different meaning for multi-level select -- see the parameter type help for more info.
                                                                                                                        • propertyKey : String
                                                                                                                          The property of the property file to use.

                                                                                                                          For example, if the property file was the following:
                                                                                                                          prop1=a,b,c,d,e
                                                                                                                          prop2=1,2,3,4
                                                                                                                          Then you could specify the property as either prop1 or prop2.
                                                                                                                        • defaultValue : String
                                                                                                                          Initial selection of the single-select or mult-select box.

                                                                                                                          In case of the multi-select box, default value can be a comma separated string.
                                                                                                                        • defaultPropertyFile : String
                                                                                                                          Absolute path (specified without using environment variables).
                                                                                                                        • defaultPropertyKey : String
                                                                                                                        • quoteValue : boolean
                                                                                                                        • visibleItemCount : int
                                                                                                                        • multiSelectDelimiter : String

                                                                                                                          Inserts this value between selections when the parameter is a multi-select.

                                                                                                                          The default when empty is ','

                                                                                                                        • bindFieldName : String
                                                                                                                        • svnPath : boolean
                                                                                                                        • svnUrl : String
                                                                                                                        • svnUserName : String
                                                                                                                        • svnPassword : String
                                                                                                                        • projectName : String
                                                                                                                        • roleBasedFilter : boolean
                                                                                                                        • description : String (optional)
                                                                                                                      • password
                                                                                                                        Pass a password to your build. The password entered here is made available to the build in plain text as an environment variable like a string parameter would be. The value will be stored encrypted on the Jenkins controller, similar to passwords in Jenkins configuration.
                                                                                                                        • name : String
                                                                                                                        • defaultValueAsSecret
                                                                                                                          • Type: class hudson.util.Secret
                                                                                                                        • description : String (optional)
                                                                                                                  • realTimeJUnitReports
                                                                                                                    Requests that test results be displayed as they appear, when possible.
                                                                                                                    • $class: 'PermalinkStorage'
                                                                                                                      • $class: 'PipelineConfigProjectProperty'
                                                                                                                        • namespace : String
                                                                                                                        • name : String
                                                                                                                        • uid : String
                                                                                                                        • resourceVersion : String
                                                                                                                        • contextAnnotation : String
                                                                                                                      • $class: 'PipelineProperty'

                                                                                                                        Configure a task name and which stage the project should be grouped by in the delivery pipeline view.

                                                                                                                        • taskName : String
                                                                                                                        • stageName : String
                                                                                                                        • descriptionTemplate : String
                                                                                                                      • pipelineTriggers
                                                                                                                      • $class: 'PipelineYAMLJobProperty'
                                                                                                                        • yamlConfiguration : String
                                                                                                                      • preserveStashes
                                                                                                                        Preserve the stashes from the most recent completed builds of this project. This allows a restarted Declarative Pipeline to reuse a stash from the build it was restarted from.
                                                                                                                        • buildCount : int (optional)
                                                                                                                      • $class: 'PriorityJobProperty'
                                                                                                                        • useJobPriority : boolean
                                                                                                                        • priority : int
                                                                                                                          The priority for this job. Priorities are used when all executors are busy to decide which job in the build queue to run next. Lower numbers are higher priority.
                                                                                                                      • $class: 'ProjectIdentity'
                                                                                                                        • projectRole : String
                                                                                                                        • familyID : String
                                                                                                                        • projectID : String
                                                                                                                      • sidebarLinks
                                                                                                                        • links
                                                                                                                            Array / List of Nested Object
                                                                                                                          • urlName : String
                                                                                                                          • displayName : String
                                                                                                                          • iconFileName : String
                                                                                                                      • $class: 'RebuildSettings'
                                                                                                                        • autoRebuild : boolean
                                                                                                                          Option enables rebuild without confirmation of parameters.
                                                                                                                          It also allows to rebuild the job without manual upload of file parameters.
                                                                                                                        • rebuildDisabled : boolean
                                                                                                                      • $class: 'RedmineProjectProperty'
                                                                                                                        Assign one of defined Redmine websites to this Jenkins project.
                                                                                                                        • redmineWebsiteName : String
                                                                                                                        • projectName : String
                                                                                                                          Identifier of project in selected Redmine. It's case insensitive and will be part of URL.
                                                                                                                          (For backward compatibility with previous redmine-plugin versions, also project name is checked)
                                                                                                                      • $class: 'RedpenJobProperty'
                                                                                                                        • credentialId : String
                                                                                                                        • logFileLocation : String
                                                                                                                          Add absolute paths (comma separated) of your Jenkins server workspace. Redpen plugin will fetch and attach all the files from the specified paths to the comment of the Jira ticket.
                                                                                                                        • unitTestFrameWork : String

                                                                                                                          Select the unit test framework to inform Redpen plugin to pick and send the log files generated by the selected framework.

                                                                                                                          Redpen plugin will search for the logs from the default/standard path of the selected framework.

                                                                                                                          If the log files are stored other than the default/standard path, then click on the 'Custom Path' button and provide a custom path.

                                                                                                                        • e2eTestFrameWork : String

                                                                                                                          Select the e2e test framework to inform Redpen plugin to pick and send the log files generated by the selected framework.

                                                                                                                          Redpen plugin will search for the logs from the default/standard path of the selected framework.

                                                                                                                          If the log files are stored other than the default/standard path, then click on the 'Custom Path' button and provide a custom path.

                                                                                                                        • coverageFrameWork : String

                                                                                                                          Select the code coverage framework to inform Redpen plugin to pick and send the log files generated by the selected framework.

                                                                                                                          Redpen plugin will search for the logs from the default/standard path of the selected framework.

                                                                                                                          If the log files are stored other than the default/standard path, then click on the 'Custom Path' button and provide a custom path.

                                                                                                                        • unitTestFrameWorkPath : String
                                                                                                                        • e2eTestFrameWorkPath : String
                                                                                                                        • coverageFrameWorkPath : String
                                                                                                                        • userEmail : String
                                                                                                                        • userPassword
                                                                                                                          • Type: class hudson.util.Secret
                                                                                                                      • $class: 'RequeueJobProperty'
                                                                                                                        • requeueJob : boolean
                                                                                                                          Requeue the job if it fails due to the remote slave going down.
                                                                                                                      • $class: 'RequiredResourcesProperty'
                                                                                                                        • resourceNames : String

                                                                                                                          When a build is scheduled, it will attempt to lock the specified resources. If some (or all) the resources are already locked by another build, the build will be queued until they are released. It is possible to specify an amount for requested resources below.

                                                                                                                        • resourceNamesVar : String

                                                                                                                          Name for the Jenkins variable to store the reserved resources in. Leave empty to disable.

                                                                                                                        • resourceNumber : String

                                                                                                                          Number of resources to request, empty value or 0 means all.
                                                                                                                          This is useful, if you have a pool of similar resources, from which you want one or more to be reserved.

                                                                                                                        • labelName : String

                                                                                                                          If you have created a pool of resources, i.e. a label, you can take it into use here. The build will select the resource(s) from the pool that includes all resources sharing the given label. Only one of Label, Groovy Expression or Resources fields may be specified.

                                                                                                                        • resourceMatchScript

                                                                                                                          You can specify a groovy expression to be evaluated each time a resource is checked to be appropriate for a build. The expression must result into a boolean value. The following variables are available, in addition to optional arguments of the currently evaluated build:

                                                                                                                          resourceName
                                                                                                                          as per resource configuration
                                                                                                                          resourceDescription
                                                                                                                          as per resource configuration
                                                                                                                          resourceLabels
                                                                                                                          java.util.List<String> of labels as per resource configuration

                                                                                                                          For matrix jobs, axis names and axis values can be referenced as well. Examples:

                                                                                                                          • resourceLabels.contains("hardcoded")
                                                                                                                          • resourceLabels.contains(axisName)
                                                                                                                          • resourceName == axisName

                                                                                                                          The script's contents need to pass approval by the Script Security Plugin.

                                                                                                                            Nested Object
                                                                                                                          • script : String
                                                                                                                          • sandbox : boolean
                                                                                                                            If checked, run this Groovy script in a sandbox with limited abilities. If unchecked, and you are not a Jenkins administrator, you will need to wait for an administrator to approve the script.
                                                                                                                          • classpath
                                                                                                                            Additional classpath entries accessible from the script.
                                                                                                                              Array / List of Nested Object
                                                                                                                            • path : String
                                                                                                                              A path or URL to a JAR file. This path should be approved by an administrator or a user with the RUN_SCRIPT permission, or the script fails. If the file or files are once approved, they are treated approved even located in another path.
                                                                                                                            • oldPath : String (optional)
                                                                                                                            • shouldBeApproved : boolean (optional)
                                                                                                                          • oldScript : String (optional)
                                                                                                                      • requireResources
                                                                                                                        • resources : Array / List of String
                                                                                                                        • $class: 'ScannerJobProperty'
                                                                                                                          • doNotScan : boolean
                                                                                                                            Tick this setting if you don't want the Build Failure Analyzer to scan builds of this project.
                                                                                                                        • $class: 'SharedWorkspace'
                                                                                                                          • name : String
                                                                                                                          • url : String
                                                                                                                        • $class: 'SpaceProjectConnectionJobProperty'
                                                                                                                          • spaceConnectionId : String
                                                                                                                          • projectKey : String
                                                                                                                        • splunkinsJobOption

                                                                                                                          Enable sending pipeline execution diagram by default

                                                                                                                          • enableDiagram : boolean (optional)
                                                                                                                            pipeline execution diagram is described in graphviz dot format, see also http://graphviz.org/documentation/
                                                                                                                        • $class: 'SpringProfilesJobProperty'
                                                                                                                          • springProfiles : String (optional)
                                                                                                                        • $class: 'TemplateImplementationProperty'
                                                                                                                          • templateJobName : String
                                                                                                                          • exclusions : Array / List of String
                                                                                                                            • syncDescription : boolean
                                                                                                                            • syncDisabled : boolean
                                                                                                                            • syncMatrixAxis : boolean
                                                                                                                            • syncBuildTriggers : boolean
                                                                                                                            • syncSecurity : boolean
                                                                                                                            • syncScm : boolean
                                                                                                                            • syncOwnership : boolean
                                                                                                                            • syncAssignedLabel : boolean
                                                                                                                          • $class: 'TemplateProperty'
                                                                                                                            • $class: 'TemplateWorkflowInstances'
                                                                                                                              • instances
                                                                                                                                • Type: java.util.Map<java.lang.String, org.jenkins.plugin.templateWorkflows.TemplateWorkflowInstance>
                                                                                                                            • $class: 'TemplateWorkflowProperty'
                                                                                                                              • templateName : String
                                                                                                                              • isStartingWorkflowJob : boolean
                                                                                                                            • throttleJobProperty

                                                                                                                              Note that the Throttle Concurrent Builds configuration here does not work for Pipeline jobs.

                                                                                                                              For that, use the throttle step.

                                                                                                                              • maxConcurrentPerNode : int

                                                                                                                                The maximum number of concurrent builds of this project (or category) to be allowed to run per node.

                                                                                                                              • maxConcurrentTotal : int

                                                                                                                                The maximum number of concurrent builds of this project (or category) to be allowed to run at any one time, across all nodes.

                                                                                                                              • categories : Array / List of String

                                                                                                                                Categories can be used to throttle multiple projects.

                                                                                                                                Categories can be optionally configured with pairs of throttled Jenkins node labels.
                                                                                                                                Pairs can make each maximum applicable to nodes with matching labels only.
                                                                                                                                That is achieved by adding such Maximum Per Labeled Node pair(s) to any category.
                                                                                                                                Category's Maximum Concurrent Builds Per Node is superseded by matching-pair's maximum.

                                                                                                                                • throttleEnabled : boolean
                                                                                                                                • throttleOption : String
                                                                                                                                • limitOneJobWithMatchingParams : boolean

                                                                                                                                  If this box is checked, only one instance of the job with matching parameter values will be allowed to run at a given time. Other instances of this job with different parameter values will be allowed to run concurrently.

                                                                                                                                  Optionally, provide a comma- or whitespace-separated list of parameters to use when comparing jobs. If blank, all parameters must match for a job to be limited to one running instance.

                                                                                                                                • paramsToUseForLimit : String
                                                                                                                                • matrixOptions
                                                                                                                                    Nested Object
                                                                                                                                  • throttleMatrixBuilds : boolean
                                                                                                                                  • throttleMatrixConfigurations : boolean
                                                                                                                              • $class: 'TracProjectProperty'
                                                                                                                                • tracWebsite : String
                                                                                                                              • $class: 'TrackingGitProperty'

                                                                                                                                If enabled, the Git revisions that are checked out for this project will track the revisions in another project.

                                                                                                                                The Git configuration must still be entered.

                                                                                                                                When building, the TRACKING_GIT_BUILD environment variable will contain the URL of the tracked build.

                                                                                                                                It is generally useless to use SCM polling if Git tracking is enabled. Instead, trigger this project from the tracked project.

                                                                                                                                • sourceProject : String
                                                                                                                                  The name of the project to track
                                                                                                                                • toTrack
                                                                                                                                  Select which build you want to track.
                                                                                                                                  • Last stable build
                                                                                                                                  • Last successful build
                                                                                                                                  • Last build (regardless of success or failure)
                                                                                                                                  • Last failed build
                                                                                                                                  • Values: LAST_STABLE, LAST_SUCCESSFUL, LAST_BUILD, LAST_FAILED_BUILD
                                                                                                                              • $class: 'TrackingSVNProperty'

                                                                                                                                If enabled, the Subversion revisions that are checked out for this project will track the revisions in another project.

                                                                                                                                The Subversion configuration must still be entered. More than one module may be used, and the revision tracking will happen for any URL in this project that exactly matches the tracked project. For all other modules, the latest revision will be used.

                                                                                                                                When building, the TRACKING_SVN_BUILD environment variable will contain the URL of the tracked build.

                                                                                                                                It is generally useless to use SCM polling if SVN tracking is enabled. Instead, trigger this project from the tracked project.

                                                                                                                                • sourceProject : String
                                                                                                                                  The name of the project to track
                                                                                                                                • toTrack
                                                                                                                                  Select which build you want to track.
                                                                                                                                  • Last stable build
                                                                                                                                  • Last successful build
                                                                                                                                  • Last build (regardless of success or failure)
                                                                                                                                  • Last failed build
                                                                                                                                  • Values: LAST_STABLE, LAST_SUCCESSFUL, LAST_BUILD, LAST_FAILED_BUILD
                                                                                                                                • ignoredURLs : String
                                                                                                                                  Comma-separated list of URLs to ignore. For these SVN urls, head is checked out.
                                                                                                                              • $class: 'TransifexProjectProperty'
                                                                                                                                • projectUrl : String
                                                                                                                              • $class: 'UpdateTransientProperty'
                                                                                                                                • $class: 'UrlProperty'
                                                                                                                                  • url : String

                                                                                                                                    The live branch url has the following format: https://www.gitcolony.com/event/number/branch/token.

                                                                                                                                    Note: you can use build parameters in any of the components by using the $var syntax.

                                                                                                                                    For example: "https://www.gitcolony.com/event/1234/$branch/111111" would expand the branch name from the branch build parameter.

                                                                                                                                    For more information visit www.gitcolony.com.

                                                                                                                                • $class: 'WallDisplayJobProperty'
                                                                                                                                  • wallDisplayName : String
                                                                                                                                    Overrides the text to use for the Walldisplay plugin. By default the jobs name is used.
                                                                                                                                  • wallDisplayBgPicture : String
                                                                                                                                    Adds a translucent custom picture in the background of your task. By default there is no background picture.
                                                                                                                                  • wallDisplayOrder : String
                                                                                                                                • $class: 'WatcherJobProperty'
                                                                                                                                  Send notification email to the group of recipients whenever job configuration changes. Users are notified on:
                                                                                                                                  • Job renamed
                                                                                                                                  • Job deleted
                                                                                                                                  • Job configuration updated
                                                                                                                                  • watcherAddresses : String
                                                                                                                                • $class: 'WavefrontJobProperty'
                                                                                                                                  • enableSendingJacocoReportData : boolean (optional)
                                                                                                                                  • enableSendingJobParameters : boolean (optional)
                                                                                                                                  • enableSendingJunitReportData : boolean (optional)
                                                                                                                                  • jobParameters : String (optional)
                                                                                                                                • $class: 'WorkflowJobProperty'
                                                                                                                                  • namespace : String
                                                                                                                                  • name : String
                                                                                                                                  • uid : String
                                                                                                                                  • resourceVersion : String
                                                                                                                                  • contextAnnotation : String
                                                                                                                                • $class: 'YouTrackProjectProperty'
                                                                                                                                • $class: 'ZanataWebhookProjectProperty'
                                                                                                                                  • zanataWebhookSecret
                                                                                                                                    • Type: class hudson.util.Secret
                                                                                                                                  • URLForWebhook : String
                                                                                                                                    Use this URL to register webhook in Zanata server. See Zanata documentation for webhook for more detail. IMPORTANT:The URL is based on your job name. If you change your job name after registering the webhook, you will need to update it in Zanata.
                                                                                                                                • $class: 'ZenTimestampJobProperty'
                                                                                                                                  • changeBUILDID : boolean

                                                                                                                                    The Jenkins BUILD_TIMESTAMP variable uses by default the date and time 'YYYY-MM-DD_hh-mm-ss' of the international standard.
                                                                                                                                    You can change this format by providing your own pattern.

                                                                                                                                  • pattern : String

                                                                                                                                    You must specify a java.text.SimpleDateFormat pattern. For example give the following value: yyyyMMddHHmmss.

                                                                                                                                • authorizationMatrixFork
                                                                                                                                  • entries
                                                                                                                                      Array / List of Nested Choice of Objects
                                                                                                                                    • group
                                                                                                                                      • name : String
                                                                                                                                      • permissions : Array / List of String
                                                                                                                                      • user
                                                                                                                                        • name : String
                                                                                                                                        • permissions : Array / List of String
                                                                                                                                        • userOrGroup
                                                                                                                                          • name : String
                                                                                                                                          • permissions : Array / List of String
                                                                                                                                        • inheritanceStrategy (optional)
                                                                                                                                            Nested Choice of Objects
                                                                                                                                          • inheritingGlobal
                                                                                                                                            • inheriting
                                                                                                                                              • nonInheriting
                                                                                                                                            • $class: 'com.tikal.hudson.plugins.notification.HudsonNotificationProperty'
                                                                                                                                              • endpoints
                                                                                                                                                Sends notifications about Job status to the defined endpoints using UDP, TCP or HTTP protocols.
                                                                                                                                                  Array / List of Nested Object
                                                                                                                                                • urlInfo
                                                                                                                                                    Nested Object
                                                                                                                                                  • urlType
                                                                                                                                                    • Values: SECRET, PUBLIC
                                                                                                                                                  • urlOrId : String
                                                                                                                                                • branch : String (optional)
                                                                                                                                                • buildNotes : String (optional)
                                                                                                                                                • event : String (optional)
                                                                                                                                                • format (optional)
                                                                                                                                                  • Values: XML, JSON
                                                                                                                                                • loglines : int (optional)
                                                                                                                                                • protocol (optional)
                                                                                                                                                  • Values: UDP, TCP, HTTP
                                                                                                                                                • retries : int (optional)
                                                                                                                                                • timeout : int (optional)
                                                                                                                                            • $class: 'hudson.plugins.jobConfigHistory.JobLocalConfiguration'
                                                                                                                                              • changeReasonComment : String
                                                                                                                                                The change reason provided at the diff view.
                                                                                                                                            • $class: 'hudson.plugins.svn_partial_release_mgr.ui.JobPropertyImpl'
                                                                                                                                              • authorizationMatrix
                                                                                                                                                • entries
                                                                                                                                                    Array / List of Nested Choice of Objects
                                                                                                                                                  • group
                                                                                                                                                    • name : String
                                                                                                                                                    • permissions : Array / List of String
                                                                                                                                                    • user
                                                                                                                                                      • name : String
                                                                                                                                                      • permissions : Array / List of String
                                                                                                                                                      • userOrGroup
                                                                                                                                                        • name : String
                                                                                                                                                        • permissions : Array / List of String
                                                                                                                                                      • inheritanceStrategy (optional)
                                                                                                                                                          Nested Choice of Objects
                                                                                                                                                        • inheritingGlobal
                                                                                                                                                          • inheriting
                                                                                                                                                            • nonInheriting
                                                                                                                                                          • $class: 'it.dockins.dockerslaves.spec.ContainerSetDefinition'
                                                                                                                                                          • rateLimitBuilds
                                                                                                                                                            • throttle
                                                                                                                                                              Enforces a minimum time between builds based on the desired maximum rate.
                                                                                                                                                              Note: this does not enforce an "average" rate, it only looks at the time since last build.
                                                                                                                                                                Nested Object
                                                                                                                                                              • count : int
                                                                                                                                                              • durationName : String
                                                                                                                                                              • userBoost : boolean
                                                                                                                                                          • $class: 'jenkins.plugins.elanceodesk.workplace.notifier.WebhookJobProperty'
                                                                                                                                                            • webhooks
                                                                                                                                                                Array / List of Nested Object
                                                                                                                                                              • url : String
                                                                                                                                                              • startNotification : boolean
                                                                                                                                                              • notifySuccess : boolean
                                                                                                                                                              • notifyAborted : boolean
                                                                                                                                                              • notifyNotBuilt : boolean
                                                                                                                                                              • notifyUnstable : boolean
                                                                                                                                                              • notifyFailure : boolean
                                                                                                                                                              • notifyBackToNormal : boolean
                                                                                                                                                              • timeout : int
                                                                                                                                                          • $class: 'jenkins.plugins.mdtdeploy.JobPropertyImpl'
                                                                                                                                                            • office365ConnectorWebhooks
                                                                                                                                                              • webhooks
                                                                                                                                                                  Array / List of Nested Object
                                                                                                                                                                • url : String
                                                                                                                                                                  Paste the URL generated in the Connectors Page , e.g. http://outlook.office.com/webhook/...ca/JenkinsCI/...a7/user@tenant.com/test
                                                                                                                                                                  Can contain variable references.
                                                                                                                                                                • factDefinitions (optional)
                                                                                                                                                                  Defines custom facts. Value can be written as token macro
                                                                                                                                                                    Array / List of Nested Object
                                                                                                                                                                  • name : String (optional)
                                                                                                                                                                  • template : String (optional)
                                                                                                                                                                • macros (optional)
                                                                                                                                                                  Defines additional conditions that must be met to send the notification. It consists from pair of template and value. If template defined as token macro is equal to value then the notification is sent. It is enough that one condition from this section is met. There are many plugins that support macros so filtering by Git event or build parameter is now possible.
                                                                                                                                                                    Array / List of Nested Object
                                                                                                                                                                  • template : String
                                                                                                                                                                  • value : String
                                                                                                                                                                • name : String (optional)
                                                                                                                                                                  Allows to provide name fo the connection. Name is not mandatory but helps managing when there are many connection assigned to the build
                                                                                                                                                                • notifyAborted : boolean (optional)
                                                                                                                                                                • notifyBackToNormal : boolean (optional)
                                                                                                                                                                • notifyFailure : boolean (optional)
                                                                                                                                                                • notifyNotBuilt : boolean (optional)
                                                                                                                                                                • notifyRepeatedFailure : boolean (optional)
                                                                                                                                                                • notifySuccess : boolean (optional)
                                                                                                                                                                • notifyUnstable : boolean (optional)
                                                                                                                                                                • startNotification : boolean (optional)
                                                                                                                                                                • timeout : int (optional)
                                                                                                                                                                  Sets connection timeout (in milliseconds) for TCP and HTTP.
                                                                                                                                                            • $class: 'org.jenkins.ci.plugins.html5_notifier.JobPropertyImpl'
                                                                                                                                                              • skip : boolean
                                                                                                                                                                Whether or not to skip HTML5 notifications for this job.
                                                                                                                                                            • $class: 'org.jenkinsci.plugins.ZMQEventPublisher.HudsonNotificationProperty'
                                                                                                                                                              • enabled : boolean
                                                                                                                                                            • $class: 'org.jenkinsci.plugins.periodicreincarnation.JobLocalConfiguration'
                                                                                                                                                              • optionalBlock
                                                                                                                                                                  Nested Object
                                                                                                                                                                • isEnabled : boolean
                                                                                                                                                                • maxDepth : int
                                                                                                                                                                • isLocallyDeactivated : boolean
                                                                                                                                                            • $class: 'sh.hyper.hyperslaves.spec.ContainerSetDefinition'
                                                                                                                                                              • buildHostImage
                                                                                                                                                                Docker image used to host the build environment and run build steps. Using this option, you have full control on your build environment to make it fully reproducible and isolated from other builds. You can use arbitrary docker images here, setup with the builds tools required by your job. There's no prerequisites on the docker image as the jenkins infrastructure setup is handled transparently.
                                                                                                                                                                  Nested Choice of Objects
                                                                                                                                                                • $class: 'ImageIdContainerDefinition'
                                                                                                                                                                  • image : String
                                                                                                                                                                  • size : String
                                                                                                                                                                  • forcePull : boolean
                                                                                                                                                                    Always pull the image before launching the container, to ensure the latest is ran during the build. Usefull if you use a latest image. Will slow down the build, but ensure you always run the up-to-date image.

                                                                                                                                                          readTrusted: Read trusted file from SCM

                                                                                                                                                          From a multibranch Pipeline project, reads a file from the associated SCM and returns its contents. Unlike the readFile step, no workspace is required. If the associated branch is not trusted, yet the file has been modified from its trusted version, an error is thrown. Thus this step is useful for loading scripts or other files which might otherwise be used to run malicious commands. Like checkout scm, as a convenience it may also be used from a standalone project configured with Pipeline from SCM, in which case there is no security aspect.
                                                                                                                                                          • path : String
                                                                                                                                                            Relative (slash-separated) path to the file from the SCM root. Thus readTrusted 'subdir/file' is similar to node {checkout scm; readFile 'subdir/file'}.

                                                                                                                                                          resolveScm: Resolves an SCM from an SCM Source and a list of candidate target branch names

                                                                                                                                                          When you have a multi-branch pipeline that checks out other sibling repositories, you may want to check out the matching branch from that sibling repository (assuming it exists) but fall back to the main branch if there is no matching branch.

                                                                                                                                                          This step lets you create a branch in the primary repository and then when you need downstream / upstream changes in the sibling repository you can just create a matching branch and it will be resolved automatically. For example:

                                                                                                                                                          // checkout the main source
                                                                                                                                                          dir('main'){
                                                                                                                                                              // this will checkout the source repository that is driving the multi-branch pipeline
                                                                                                                                                              checkout scm
                                                                                                                                                          }
                                                                                                                                                          // now checkout the tests
                                                                                                                                                          dir('tests'){
                                                                                                                                                              // this will check if there is a branch with the same name as the current branch in
                                                                                                                                                              // https://example.com/example.git and use that for the checkout, but if there is no
                                                                                                                                                              // branch with the same name it will fall back to the master branch
                                                                                                                                                              checkout resolveScm(source: git('https://example.com/example.git'), targets: [BRANCH_NAME,'master']
                                                                                                                                                          }
                                                                                                                                                          // rest of pipeline
                                                                                                                                                          

                                                                                                                                                          The return value is the resolved SCM instance (or null if ignoring errors). Where the SCM implementation supports it, the SCM instance will be pinned to the current head revision of the resolved branch. This can be useful if, for example, you want to check out the resolved branch on multiple nodes because all the nodes will get the same revision.

                                                                                                                                                          • source
                                                                                                                                                            The source repository from which to resolve the target branches.
                                                                                                                                                              Nested Choice of Objects
                                                                                                                                                            • $class: 'BacklogPullRequestSCMSource'
                                                                                                                                                            • multiBranch
                                                                                                                                                            • dagshubScmSource
                                                                                                                                                            • gerrit
                                                                                                                                                              • remote : String
                                                                                                                                                                Specify the URL of this remote repository. This uses the same syntax as your git clone command.
                                                                                                                                                              • apiKey (optional)
                                                                                                                                                                Gerrit web-hook apiKey used as additional security layer to prevent accidental SCM scans.
                                                                                                                                                                • Type: class hudson.util.Secret
                                                                                                                                                              • browser (optional)
                                                                                                                                                                  Nested Choice of Objects
                                                                                                                                                                • assembla
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                    Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                  • repoName : String
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                • bitbucketServer
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                    Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                • bitbucket
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                    Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                • cgit
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                    Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                • fisheye
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                    Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                • gitblit
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                    Specify the root URL serving this repository.
                                                                                                                                                                  • projectName : String
                                                                                                                                                                    Specify the name of the project in GitBlit.
                                                                                                                                                                • $class: 'GitBucketBrowser'
                                                                                                                                                                  • url : String
                                                                                                                                                                • gitLab
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                    Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                  • version : String (optional)
                                                                                                                                                                    Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                • gitLabBrowser
                                                                                                                                                                  Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                  • projectUrl : String
                                                                                                                                                                    Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                • gitList
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                    Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                • gitWeb
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                    Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                • $class: 'GiteaBrowser'
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                    Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                • github
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                    Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                • gitiles
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                    Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                • $class: 'GitoriousWeb'
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                    Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                • gogs
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                    Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                • kiln
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                    Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                • phabricator
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                    Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                  • repo : String
                                                                                                                                                                    Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                • redmine
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                    Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                • rhodeCode
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                    Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                    Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                • jbSpace
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                    Provide the absolute URL to your repository in JetBrains SpaceCode in the following format: https://<your SpaceCode instance>/p/<project key>/repositories/<repository name>
                                                                                                                                                                • $class: 'Stash'
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                    Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                • teamFoundation
                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                    Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                    If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                  • $class: 'TuleapBrowser'
                                                                                                                                                                    Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                    • repositoryUrl : String
                                                                                                                                                                      The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                  • viewgit
                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                      Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                    • projectName : String
                                                                                                                                                                      Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                • credentialsId : String (optional)
                                                                                                                                                                  Credentials used to scan branches and check out sources.
                                                                                                                                                                • extensions (optional)
                                                                                                                                                                    Array / List of Nested Choice of Objects
                                                                                                                                                                  • authorInChangelog
                                                                                                                                                                    The default behavior is to use the Git commit's "Committer" value in Jenkins' build changesets. If this option is selected, the Git commit's "Author" value would be used instead.
                                                                                                                                                                    • $class: 'BuildChooserSetting'
                                                                                                                                                                      When you are interested in using a job to build multiple heads (most typically multiple branches), you can choose how Jenkins choose what branches to build in what order.

                                                                                                                                                                      This extension point in Jenkins is used by many other plugins to control the job to build specific commits. When you activate those plugins, you may see them installing a custom strategy here.

                                                                                                                                                                      • buildChooser
                                                                                                                                                                          Nested Choice of Objects
                                                                                                                                                                        • $class: 'AlternativeBuildChooser'
                                                                                                                                                                          • $class: 'AncestryBuildChooser'
                                                                                                                                                                            • maximumAgeInDays : int
                                                                                                                                                                            • ancestorCommitSha1 : String
                                                                                                                                                                          • $class: 'DefaultBuildChooser'
                                                                                                                                                                            • $class: 'DeflakeGitBuildChooser'
                                                                                                                                                                              • $class: 'GerritTriggerBuildChooser'
                                                                                                                                                                                • $class: 'InverseBuildChooser'
                                                                                                                                                                              • buildSingleRevisionOnly
                                                                                                                                                                                Disable scheduling for multiple candidate revisions.
                                                                                                                                                                                If we have 3 branches:
                                                                                                                                                                                ----A--.---.--- B
                                                                                                                                                                                         \-----C
                                                                                                                                                                                jenkins would try to build (B) and (C).
                                                                                                                                                                                This behaviour disables this and only builds one of them.
                                                                                                                                                                                It is helpful to reduce the load of the Jenkins infrastructure when the SCM system like Bitbucket or GitHub should decide what commits to build.
                                                                                                                                                                                • changelogToBranch
                                                                                                                                                                                  This method calculates the changelog against the specified branch.
                                                                                                                                                                                  • options
                                                                                                                                                                                      Nested Object
                                                                                                                                                                                    • compareRemote : String
                                                                                                                                                                                      Name of the repository, such as origin, that contains the branch you specify below.
                                                                                                                                                                                    • compareTarget : String
                                                                                                                                                                                      The name of the branch within the named repository to compare against.
                                                                                                                                                                                • checkoutOption
                                                                                                                                                                                  • timeout : int
                                                                                                                                                                                    Specify a timeout (in minutes) for checkout.
                                                                                                                                                                                    This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                    You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                • cleanBeforeCheckout
                                                                                                                                                                                  Clean up the workspace before every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                  • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                    Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                • cleanAfterCheckout
                                                                                                                                                                                  Clean up the workspace after every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                  • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                    Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                • cloneOption
                                                                                                                                                                                  • shallow : boolean
                                                                                                                                                                                    Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                  • noTags : boolean
                                                                                                                                                                                    Deselect this to perform a clone without tags, saving time and disk space when you just want to access what is specified by the refspec.
                                                                                                                                                                                  • reference : String
                                                                                                                                                                                    Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                    This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                  • timeout : int
                                                                                                                                                                                    Specify a timeout (in minutes) for clone and fetch operations.
                                                                                                                                                                                    This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                    You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                  • depth : int (optional)
                                                                                                                                                                                    Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                  • honorRefspec : boolean (optional)
                                                                                                                                                                                    Perform initial clone using the refspec defined for the repository. This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
                                                                                                                                                                                • $class: 'CodeCommitURLHelper'
                                                                                                                                                                                  • credentialId : String

                                                                                                                                                                                    OPTIONAL: Select the credentials to use.
                                                                                                                                                                                    If not specified, defaults to the DefaultAWSCredentialsProviderChain behaviour - *FROM THE JENKINS INSTANCE*

                                                                                                                                                                                    In the latter case, usage of IAM Role Profiles seems not to work, thus relying on environment variables / system properties or the ~/.aws/credentials file, thus not recommended.

                                                                                                                                                                                  • repositoryName : String
                                                                                                                                                                                • $class: 'DisableRemotePoll'
                                                                                                                                                                                  Git plugin uses git ls-remote polling mechanism by default when configured with a single branch (no wildcards!). This compare the latest built commit SHA with the remote branch without cloning a local copy of the repo.

                                                                                                                                                                                  If you don't want to / can't use this.

                                                                                                                                                                                  If this option is selected, polling will require a workspace and might trigger unwanted builds (see JENKINS-10131).
                                                                                                                                                                                  • $class: 'ExcludeFromChangeSet'
                                                                                                                                                                                    • $class: 'ExcludeFromPoll'
                                                                                                                                                                                      • lfs
                                                                                                                                                                                        Enable git large file support for the workspace by pulling large files after the checkout completes. Requires that the controller and each agent performing an LFS checkout have installed `git lfs`.
                                                                                                                                                                                        • $class: 'GitSCMChecksExtension'
                                                                                                                                                                                          • verboseConsoleLog : boolean (optional)
                                                                                                                                                                                            If this option is checked, verbose log will be output to build console; the verbose log is useful for debugging the publisher creation.
                                                                                                                                                                                        • $class: 'GitSCMStatusChecksExtension'
                                                                                                                                                                                          • name : String (optional)
                                                                                                                                                                                          • skip : boolean (optional)
                                                                                                                                                                                          • skipProgressUpdates : boolean (optional)
                                                                                                                                                                                          • suppressLogs : boolean (optional)
                                                                                                                                                                                          • unstableBuildNeutral : boolean (optional)
                                                                                                                                                                                        • $class: 'GitTagMessageExtension'
                                                                                                                                                                                          If the revision checked out has a git tag associated with it, the tag name will be exported during the build as GIT_TAG_NAME.
                                                                                                                                                                                          If a message was specified when creating the tag, then that message will be exported during the build as the GIT_TAG_MESSAGE environment variable.
                                                                                                                                                                                          If no tag message was specified, the commit message will be used.
                                                                                                                                                                                          If you ticked the Use most recent tag option, and the revision checked out has no git tag associated with it, the parent commits will be searched for a git tag, and the rules stated above will apply to the first parent commit with a git tag.

                                                                                                                                                                                          If the revision has more than one tag associated with it, only the most recent tag will be taken into account, unless the refspec contains "refs/tags/" — i.e. builds are only triggered when certain tag names or patterns are matched — in which case the exact tag name that triggered the build will be used, even if it's not the most recent tag for this commit.
                                                                                                                                                                                          For this reason, if you're not using a tag-specific refspec but you are using the "Create a tag for every build" behaviour, you should make sure that the build-tagging behaviour is configured to run after this "export git tag message" behaviour.

                                                                                                                                                                                          Tag and commit messages which span multiple lines are no problem, though only the first 10000 lines of a tag's message will be exported.
                                                                                                                                                                                          • useMostRecentTag : boolean (optional)
                                                                                                                                                                                        • $class: 'IgnoreNotifyCommit'
                                                                                                                                                                                          If checked, this repository will be ignored when the notifyCommit-URL is accessed regardless of if the repository matches or not.
                                                                                                                                                                                          • localBranch
                                                                                                                                                                                            If given, checkout the revision to build as HEAD on this branch.

                                                                                                                                                                                            If selected, and its value is an empty string or "**", then the branch name is computed from the remote branch without the origin. In that case, a remote branch origin/master will be checked out to a local branch named master, and a remote branch origin/develop/new-feature will be checked out to a local branch named develop/newfeature.

                                                                                                                                                                                            Please note that this has not been tested with submodules.

                                                                                                                                                                                            • localBranch : String
                                                                                                                                                                                          • $class: 'MessageExclusion'
                                                                                                                                                                                            • excludedMessage : String
                                                                                                                                                                                              If set, and Jenkins is set to poll for changes, Jenkins will ignore any revisions committed with message matched to Pattern when determining if a build needs to be triggered. This can be used to exclude commits done by the build itself from triggering another build, assuming the build server commits the change with a distinct message.

                                                                                                                                                                                              Exclusion uses Pattern matching

                                                                                                                                                                                              .*\[maven-release-plugin\].*
                                                                                                                                                                                              The example above illustrates that if only revisions with "[maven-release-plugin]" message in first comment line have been committed to the SCM a build will not occur.

                                                                                                                                                                                              You can create more complex patterns using embedded flag expressions.
                                                                                                                                                                                              (?s).*FOO.*
                                                                                                                                                                                              This example will search FOO message in all comment lines.
                                                                                                                                                                                          • $class: 'PathRestriction'
                                                                                                                                                                                            If set, and Jenkins is set to poll for changes, Jenkins will pay attention to included and/or excluded files and/or folders when determining if a build needs to be triggered.

                                                                                                                                                                                            Using this behaviour will preclude the faster git ls-remote polling mechanism, forcing polling to require a workspace thus sometimes triggering unwanted builds, as if you had selected the Force polling using workspace extension as well.
                                                                                                                                                                                            • includedRegions : String
                                                                                                                                                                                              Each inclusion uses java regular expression pattern matching, and must be separated by a new line. An empty list implies that everything is included.

                                                                                                                                                                                                  myapp/src/main/web/.*\.html
                                                                                                                                                                                                  myapp/src/main/web/.*\.jpeg
                                                                                                                                                                                                  myapp/src/main/web/.*\.gif
                                                                                                                                                                                                
                                                                                                                                                                                              The example above illustrates that a build will only occur, if html/jpeg/gif files have been committed to the SCM. Exclusions take precedence over inclusions, if there is an overlap between included and excluded regions.
                                                                                                                                                                                            • excludedRegions : String
                                                                                                                                                                                              Each exclusion uses java regular expression pattern matching, and must be separated by a new line.

                                                                                                                                                                                                  myapp/src/main/web/.*\.html
                                                                                                                                                                                                  myapp/src/main/web/.*\.jpeg
                                                                                                                                                                                                  myapp/src/main/web/.*\.gif
                                                                                                                                                                                                
                                                                                                                                                                                              The example above illustrates that if only html/jpeg/gif files have been committed to the SCM a build will not occur.
                                                                                                                                                                                          • perBuildTag
                                                                                                                                                                                            Create a tag in the workspace for every build to unambiguously mark the commit that was built. You can combine this with Git publisher to push the tags to the remote repository.
                                                                                                                                                                                            • $class: 'PreBuildMerge'
                                                                                                                                                                                              These options allow you to perform a merge to a particular branch before building. For example, you could specify an integration branch to be built, and to merge to master. In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful. It then may push the merge back to the remote repository if the Git Push post-build action is selected.
                                                                                                                                                                                              • options
                                                                                                                                                                                                  Nested Object
                                                                                                                                                                                                • mergeTarget : String
                                                                                                                                                                                                  The name of the branch within the named repository to merge to, such as master.
                                                                                                                                                                                                • fastForwardMode (optional)
                                                                                                                                                                                                  Merge fast-forward mode selection.
                                                                                                                                                                                                  The default, --ff, gracefully falls back to a merge commit when required.
                                                                                                                                                                                                  For more information, see the Git Merge Documentation
                                                                                                                                                                                                  • Values: FF, FF_ONLY, NO_FF
                                                                                                                                                                                                • mergeRemote : String (optional)
                                                                                                                                                                                                  Name of the repository, such as origin, that contains the branch you specify below. If left blank, it'll default to the name of the first repository configured above.
                                                                                                                                                                                                • mergeStrategy (optional)
                                                                                                                                                                                                  Merge strategy selection. This feature is not fully implemented in JGIT.
                                                                                                                                                                                                  • Values: DEFAULT, RESOLVE, RECURSIVE, OCTOPUS, OURS, SUBTREE, RECURSIVE_THEIRS
                                                                                                                                                                                            • pretestedIntegration
                                                                                                                                                                                              • gitIntegrationStrategy
                                                                                                                                                                                                  Nested Choice of Objects
                                                                                                                                                                                                • accumulated

                                                                                                                                                                                                  Accumulated Commit Strategy

                                                                                                                                                                                                  This strategy merges your commits with the --no-ff switch
                                                                                                                                                                                                  • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                • ffonly

                                                                                                                                                                                                  Fast Forward only (--ff-only) Strategy

                                                                                                                                                                                                  This strategy fast-forward only using the --ff-only switch - or fails
                                                                                                                                                                                                  • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                • squash

                                                                                                                                                                                                  Squashed Commit Strategy

                                                                                                                                                                                                  This strategy squashes all your commit on a given branch with the --squash option
                                                                                                                                                                                                • integrationBranch : String

                                                                                                                                                                                                  What to specify

                                                                                                                                                                                                  The branch name must match your integration branch name. No trailing slash.

                                                                                                                                                                                                  Merge is performed the following way

                                                                                                                                                                                                  Squash commit
                                                                                                                                                                                                              git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                              git merge --squash <Branch matched by git>
                                                                                                                                                                                                              git commit -C <Branch matched by git>
                                                                                                                                                                                                  Accumulated commit
                                                                                                                                                                                                              git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                              git merge -m <commitMsg> <Branch matched by git> --no-ff

                                                                                                                                                                                                  When changes are pushed to the integration branch?

                                                                                                                                                                                                  Changes are only ever pushed when the build results is SUCCESS

                                                                                                                                                                                                              git push <Repository name> <Branch name>
                                                                                                                                                                                                • repoName : String

                                                                                                                                                                                                  What to specify

                                                                                                                                                                                                  The repository name. In git the repository is always the name of the remote. So if you have specified a repository name in your Git configuration. You need to specify the exact same name here, otherwise no integration will be performed. We do the merge based on this.

                                                                                                                                                                                                  No trailing slash on repository name.

                                                                                                                                                                                                  Remember to specify this when working with NAMED repositories in Git

                                                                                                                                                                                              • pruneStaleBranch
                                                                                                                                                                                                Run "git remote prune" for each remote, to prune obsolete local branches.
                                                                                                                                                                                                • pruneTags
                                                                                                                                                                                                  • pruneTags : boolean
                                                                                                                                                                                                • $class: 'RelativeTargetDirectory'
                                                                                                                                                                                                  • relativeTargetDir : String
                                                                                                                                                                                                    Specify a local directory (relative to the workspace root) where the Git repository will be checked out. If left empty, the workspace root itself will be used.

                                                                                                                                                                                                    This extension should not be used in Jenkins Pipeline (either declarative or scripted). Jenkins Pipeline already provides standard techniques for checkout to a subdirectory. Use ws and dir in Jenkins Pipeline rather than this extension.

                                                                                                                                                                                                • $class: 'ScmName'

                                                                                                                                                                                                  Unique name for this SCM. Needed when using Git within the Multi SCM plugin.

                                                                                                                                                                                                  • name : String
                                                                                                                                                                                                • $class: 'SparseCheckoutPaths'

                                                                                                                                                                                                  Specify the paths that you'd like to sparse checkout. This may be used for saving space (Think about a reference repository). Be sure to use a recent version of Git, at least above 1.7.10

                                                                                                                                                                                                  • sparseCheckoutPaths
                                                                                                                                                                                                      Array / List of Nested Object
                                                                                                                                                                                                    • path : String
                                                                                                                                                                                                • submodule
                                                                                                                                                                                                  • depth : int (optional)
                                                                                                                                                                                                    Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                  • disableSubmodules : boolean (optional)
                                                                                                                                                                                                    By disabling support for submodules you can still keep using basic git plugin functionality and just have Jenkins to ignore submodules completely as if they didn't exist.
                                                                                                                                                                                                  • parentCredentials : boolean (optional)
                                                                                                                                                                                                    Use credentials from the default remote of the parent project.
                                                                                                                                                                                                  • recursiveSubmodules : boolean (optional)
                                                                                                                                                                                                    Retrieve all submodules recursively (uses '--recursive' option which requires git>=1.6.5)
                                                                                                                                                                                                  • reference : String (optional)
                                                                                                                                                                                                    Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                    This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                    To prepare a reference folder with multiple subprojects, create a bare git repository and add all the remote urls then perform a fetch:
                                                                                                                                                                                                      git init --bare
                                                                                                                                                                                                      git remote add SubProject1 https://gitrepo.com/subproject1
                                                                                                                                                                                                      git remote add SubProject2 https://gitrepo.com/subproject2
                                                                                                                                                                                                      git fetch --all
                                                                                                                                                                                                      
                                                                                                                                                                                                  • shallow : boolean (optional)
                                                                                                                                                                                                    Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                  • threads : int (optional)
                                                                                                                                                                                                    Specify the number of threads that will be used to update submodules.
                                                                                                                                                                                                    If unspecified, the command line git default thread count is used.
                                                                                                                                                                                                  • timeout : int (optional)
                                                                                                                                                                                                    Specify a timeout (in minutes) for submodules operations.
                                                                                                                                                                                                    This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                    You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                  • trackingSubmodules : boolean (optional)
                                                                                                                                                                                                    Retrieve the tip of the configured branch in .gitmodules (Uses '--remote' option which requires git>=1.8.2)
                                                                                                                                                                                                • $class: 'UserExclusion'
                                                                                                                                                                                                  • excludedUsers : String
                                                                                                                                                                                                    If set, and Jenkins is set to poll for changes, Jenkins will ignore any revisions committed by users in this list when determining if a build needs to be triggered. This can be used to exclude commits done by the build itself from triggering another build, assuming the build server commits the change with a distinct SCM user.

                                                                                                                                                                                                    Using this behaviour will preclude the faster git ls-remote polling mechanism, forcing polling to require a workspace thus sometimes triggering unwanted builds, as if you had selected the Force polling using workspace extension as well.

                                                                                                                                                                                                    Each exclusion uses exact string comparison and must be separated by a new line. User names are only excluded if they exactly match one of the names in this list.

                                                                                                                                                                                                    auto_build_user
                                                                                                                                                                                                    The example above illustrates that if only revisions by "auto_build_user" have been committed to the SCM a build will not occur.
                                                                                                                                                                                                • $class: 'UserIdentity'
                                                                                                                                                                                                  • name : String

                                                                                                                                                                                                    If given, "GIT_COMMITTER_NAME=[this]" and "GIT_AUTHOR_NAME=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                  • email : String

                                                                                                                                                                                                    If given, "GIT_COMMITTER_EMAIL=[this]" and "GIT_AUTHOR_EMAIL=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                • $class: 'WipeWorkspace'
                                                                                                                                                                                                  Delete the contents of the workspace before building, ensuring a fully fresh workspace.
                                                                                                                                                                                                • gitTool : String (optional)
                                                                                                                                                                                                • id : String (optional)
                                                                                                                                                                                                • insecureHttps : boolean (optional)
                                                                                                                                                                                                  Perform insecure HTTPS negotiation.
                                                                                                                                                                                                • traits (optional)
                                                                                                                                                                                                    Array / List of Nested Choice of Objects
                                                                                                                                                                                                  • $class: 'ApprovedPullRequestTrait'
                                                                                                                                                                                                    Sets if approvals are required before building pull requests.
                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                      Sets if approvals are required before building pull requests.
                                                                                                                                                                                                      No approval necessary.
                                                                                                                                                                                                      No check of approvals will be performed before building.
                                                                                                                                                                                                      Any approval required
                                                                                                                                                                                                      Before building the pull request must be approved. This may be performed by the author or someone else.
                                                                                                                                                                                                      Non-author approval required
                                                                                                                                                                                                      Before building the pull request must be approved and that approval cannot be performed by the author of the pull request.
                                                                                                                                                                                                      Author and Non-author approval required
                                                                                                                                                                                                      Before building the pull request must be approved by the author and a non-author.
                                                                                                                                                                                                  • authorInChangelog
                                                                                                                                                                                                    • bitbucketAgedRefsTrait
                                                                                                                                                                                                      Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                      • retentionDays : String
                                                                                                                                                                                                    • bitbucketBranchCommitSkipTrait
                                                                                                                                                                                                      Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                      • $class: 'BitbucketBranchDiscoveryTrait'
                                                                                                                                                                                                        Discovers branches in the repository.
                                                                                                                                                                                                        • bitbucketBuildStatusNotifications
                                                                                                                                                                                                          Configure the Bitbucket notifications.
                                                                                                                                                                                                          • disableNotificationForNotBuildJobs : boolean (optional)
                                                                                                                                                                                                          • sendSuccessNotificationForUnstableBuild : boolean (optional)
                                                                                                                                                                                                        • bitbucketCommitSkipTrait
                                                                                                                                                                                                          Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                          • $class: 'BitbucketGitBrowserSCMSourceTrait'
                                                                                                                                                                                                            • browser
                                                                                                                                                                                                                Nested Choice of Objects
                                                                                                                                                                                                              • assembla
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                              • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                • repoName : String
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                              • bitbucketServer
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                  Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                              • bitbucket
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                              • cgit
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                              • fisheye
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                  Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                              • gitblit
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                  Specify the root URL serving this repository.
                                                                                                                                                                                                                • projectName : String
                                                                                                                                                                                                                  Specify the name of the project in GitBlit.
                                                                                                                                                                                                              • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                • url : String
                                                                                                                                                                                                              • gitLab
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                • version : String (optional)
                                                                                                                                                                                                                  Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                              • gitLabBrowser
                                                                                                                                                                                                                Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                • projectUrl : String
                                                                                                                                                                                                                  Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                              • gitList
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                              • gitWeb
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                              • $class: 'GiteaBrowser'
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                  Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                              • github
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                  Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                              • gitiles
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                              • $class: 'GitoriousWeb'
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                              • gogs
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                              • kiln
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                              • phabricator
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                  Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                • repo : String
                                                                                                                                                                                                                  Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                              • redmine
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                              • rhodeCode
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                  Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                              • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                              • jbSpace
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                  Provide the absolute URL to your repository in JetBrains SpaceCode in the following format: https://<your SpaceCode instance>/p/<project key>/repositories/<repository name>
                                                                                                                                                                                                              • $class: 'Stash'
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                  Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                              • teamFoundation
                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                  Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                  If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                              • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                • $class: 'TuleapBrowser'
                                                                                                                                                                                                                  Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                  • repositoryUrl : String
                                                                                                                                                                                                                    The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                • viewgit
                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                  • projectName : String
                                                                                                                                                                                                                    Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                            • $class: 'BitbucketJiraValidatorTrait'
                                                                                                                                                                                                              Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                              • jiraServerIdx : int
                                                                                                                                                                                                            • $class: 'BitbucketPullRequestDiscoveryTrait'
                                                                                                                                                                                                              Discovers open pull requests in the repository.
                                                                                                                                                                                                              • buildStatusNameCustomPart
                                                                                                                                                                                                                Customize the pipeline status name used by Jenkins
                                                                                                                                                                                                                • buildStatusNameCustomPart : String (optional)
                                                                                                                                                                                                                  Enter a string to customize the status/context name for status updates published to GitLab. For a branch build the default name would be 'jenkinsci/branch'. With the buildStatusNameCustomPart 'custom' the name would be 'jenkinsci/custom/branch'. This allows to have multiple GitLab-Branch-Sources for the same GitLab-project configured.
                                                                                                                                                                                                                • buildStatusNameOverwrite : boolean (optional)
                                                                                                                                                                                                                  Overwrites the build status name including the jenkinsci default part.
                                                                                                                                                                                                                  Instead of 'jenkinsci/custom/branch' just 'custom/branch'.
                                                                                                                                                                                                                • ignoreTypeInStatusName : boolean (optional)
                                                                                                                                                                                                              • $class: 'ChangeDiscoveryTrait'
                                                                                                                                                                                                                • queryString : String

                                                                                                                                                                                                                  Provide an additional query string to search for open changes. The status:open is implicitly added and does not need to be specified. See Gerrit search operators documentation for a detailed list of the supported search operators.

                                                                                                                                                                                                                  Examples:

                                                                                                                                                                                                                  • -is:wip
                                                                                                                                                                                                                    does not include work-in-progress changes
                                                                                                                                                                                                                  • is:private
                                                                                                                                                                                                                    includes private changes

                                                                                                                                                                                                              • checkoutOption
                                                                                                                                                                                                                • extension
                                                                                                                                                                                                                    Nested Object
                                                                                                                                                                                                                  • timeout : int
                                                                                                                                                                                                                    Specify a timeout (in minutes) for checkout.
                                                                                                                                                                                                                    This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                    You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                              • cleanAfterCheckout
                                                                                                                                                                                                                • extension
                                                                                                                                                                                                                    Nested Object
                                                                                                                                                                                                                    Clean up the workspace after every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                  • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                    Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                              • cleanBeforeCheckout
                                                                                                                                                                                                                • extension
                                                                                                                                                                                                                    Nested Object
                                                                                                                                                                                                                    Clean up the workspace before every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                  • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                    Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                              • $class: 'CleanMercurialSCMSourceTrait'
                                                                                                                                                                                                                When this behaviour is present, each build will wipe any local modifications or untracked files in the repository checkout. This is often a convenient way to ensure that a build is not using any artifacts from earlier builds.
                                                                                                                                                                                                                • cloneOption
                                                                                                                                                                                                                  • extension
                                                                                                                                                                                                                      Nested Object
                                                                                                                                                                                                                    • shallow : boolean
                                                                                                                                                                                                                      Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                    • noTags : boolean
                                                                                                                                                                                                                      Deselect this to perform a clone without tags, saving time and disk space when you just want to access what is specified by the refspec.
                                                                                                                                                                                                                    • reference : String
                                                                                                                                                                                                                      Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                      This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                    • timeout : int
                                                                                                                                                                                                                      Specify a timeout (in minutes) for clone and fetch operations.
                                                                                                                                                                                                                      This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                      You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                    • depth : int (optional)
                                                                                                                                                                                                                      Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                    • honorRefspec : boolean (optional)
                                                                                                                                                                                                                      Perform initial clone using the refspec defined for the repository. This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
                                                                                                                                                                                                                • $class: 'DisableStatusUpdateTrait'
                                                                                                                                                                                                                  Disables notifications (commit status updates) to GitHub for builds.
                                                                                                                                                                                                                  • discoverOtherRefs
                                                                                                                                                                                                                    Discovers other specified refs on the repository.
                                                                                                                                                                                                                    • ref : String

                                                                                                                                                                                                                      The pattern under /refs on the remote repository to discover, can contain a wildcard.
                                                                                                                                                                                                                      Example: test/*/merged

                                                                                                                                                                                                                    • nameMapping : String (optional)

                                                                                                                                                                                                                      Mapping for how the ref can be named in for example the @Library.
                                                                                                                                                                                                                      Example: test-@{1}
                                                                                                                                                                                                                      Where @{1} replaces the first wildcard in the ref when discovered.

                                                                                                                                                                                                                      By default it will be "namespace_before_wildcard-@{1}". E.g. if ref is "test/*/merged" the default mapping would be "test-@{1}".

                                                                                                                                                                                                                  • $class: 'FilterChecksTrait'
                                                                                                                                                                                                                    • queryOperator
                                                                                                                                                                                                                      • Values: ID, SCHEME
                                                                                                                                                                                                                    • queryString : String
                                                                                                                                                                                                                      Provide a query string to search for pending checks. Depending on which mode was chosen, this either should be a checker-scheme or the UUID of a specific checker.
                                                                                                                                                                                                                  • gitLabForkDiscovery
                                                                                                                                                                                                                    Discovers merge requests where the origin project is a fork of the target project.
                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                      Determines how merge requests are discovered:
                                                                                                                                                                                                                      Merging the merge request with the current target branch revision
                                                                                                                                                                                                                      Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                      The current merge request revision
                                                                                                                                                                                                                      Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                      Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                      Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                    • trust

                                                                                                                                                                                                                      One of the great powers of merge requests is that anyone with read access to a project can fork it, commit some changes to their fork and then create a merge request against the original project with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox merge requests in order to mitigate against malicious merge requests. In order to protect against a malicious merge request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for merge requests from forks.

                                                                                                                                                                                                                      Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                      Nobody
                                                                                                                                                                                                                      Merge requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin project and not from the merge request branch on the fork project.
                                                                                                                                                                                                                      Members
                                                                                                                                                                                                                      Merge requests from collaborators to the origin project will be treated as trusted, all other merge requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the project does not have permission to query the list of contributors to the origin project then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                      Trusted Members
                                                                                                                                                                                                                      Merge requests forks will be treated as trusted if and only if the fork owner has either Developer or Maintainer or Owner Access Level in the origin project. This is the recommended policy.
                                                                                                                                                                                                                      Everyone
                                                                                                                                                                                                                      All merge requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public project hosted on a GitLab instance.
                                                                                                                                                                                                                      • Type: jenkins.scm.api.trait.SCMHeadAuthority<? super io.jenkins.plugins.gitlabbranchsource.GitLabSCMSourceRequest, ? extends jenkins.scm.api.mixin.ChangeRequestSCMHead2, ? extends jenkins.scm.api.SCMRevision>
                                                                                                                                                                                                                    • buildMRForksNotMirror : boolean (optional)
                                                                                                                                                                                                                      Add discovery of merge requests where the origin project is a fork of a certain project, but the target project is not the original forked project. To be used in case one has a GitLab project which is a fork of another project from another team, in order to isolate artefacts and allow an MR flow. This means using MRs inside that fork from branches in the fork back to the fork's default branch. (Implements https://github.com/jenkinsci/gitlab-branch-source-plugin/issues/167)
                                                                                                                                                                                                                  • browser
                                                                                                                                                                                                                    • browser
                                                                                                                                                                                                                        Nested Choice of Objects
                                                                                                                                                                                                                      • assembla
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                      • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                        • repoName : String
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                      • bitbucketServer
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                          Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                      • bitbucket
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                      • cgit
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                      • fisheye
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                          Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                      • gitblit
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                          Specify the root URL serving this repository.
                                                                                                                                                                                                                        • projectName : String
                                                                                                                                                                                                                          Specify the name of the project in GitBlit.
                                                                                                                                                                                                                      • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                        • url : String
                                                                                                                                                                                                                      • gitLab
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                        • version : String (optional)
                                                                                                                                                                                                                          Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                      • gitLabBrowser
                                                                                                                                                                                                                        Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                        • projectUrl : String
                                                                                                                                                                                                                          Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                      • gitList
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                      • gitWeb
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                      • $class: 'GiteaBrowser'
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                          Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                      • github
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                          Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                      • gitiles
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                      • $class: 'GitoriousWeb'
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                      • gogs
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                      • kiln
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                      • phabricator
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                          Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                        • repo : String
                                                                                                                                                                                                                          Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                      • redmine
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                      • rhodeCode
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                          Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                      • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                      • jbSpace
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                          Provide the absolute URL to your repository in JetBrains SpaceCode in the following format: https://<your SpaceCode instance>/p/<project key>/repositories/<repository name>
                                                                                                                                                                                                                      • $class: 'Stash'
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                          Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                      • teamFoundation
                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                          Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                          If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                      • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                        • $class: 'TuleapBrowser'
                                                                                                                                                                                                                          Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                          • repositoryUrl : String
                                                                                                                                                                                                                            The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                        • viewgit
                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                          • projectName : String
                                                                                                                                                                                                                            Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                    • gitHubAgedRefsTrait
                                                                                                                                                                                                                      Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                      • retentionDays : String
                                                                                                                                                                                                                    • gitHubBranchCommitSkipTrait
                                                                                                                                                                                                                      Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                      • gitHubCommitSkipTrait
                                                                                                                                                                                                                        Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                        • $class: 'GitHubJiraValidatorTrait'
                                                                                                                                                                                                                          Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                          • jiraServerIdx : int
                                                                                                                                                                                                                        • gitHubSourceChecks
                                                                                                                                                                                                                          • verboseConsoleLog : boolean (optional)
                                                                                                                                                                                                                            If this option is checked, verbose log will be output to build console; the verbose log is useful for debugging the publisher creation.
                                                                                                                                                                                                                        • gitHubStatusChecks
                                                                                                                                                                                                                          • name : String (optional)
                                                                                                                                                                                                                          • skip : boolean (optional)
                                                                                                                                                                                                                          • skipNotifications : boolean (optional)
                                                                                                                                                                                                                            If this option is checked, the notifications sent by the GitHub Branch Source Plugin will be disabled.
                                                                                                                                                                                                                          • skipProgressUpdates : boolean (optional)
                                                                                                                                                                                                                          • suppressLogs : boolean (optional)
                                                                                                                                                                                                                          • unstableBuildNeutral : boolean (optional)
                                                                                                                                                                                                                        • lfs
                                                                                                                                                                                                                          • gitlabAvatar
                                                                                                                                                                                                                            • disableProjectAvatar : boolean (optional)
                                                                                                                                                                                                                              Due to a GitLab bug, sometimes it is not possible to GitLab API to fetch GitLab Avatar for private projects or when the api doesn't have token access. You may choose to skip avatar for projects if you want to avoid broken or self generated avatars.
                                                                                                                                                                                                                          • gitlabMarkUnstableAsSuccess
                                                                                                                                                                                                                            • markUnstableAsSuccess : boolean (optional)
                                                                                                                                                                                                                          • gitlabSkipNotifications
                                                                                                                                                                                                                            • gitTool
                                                                                                                                                                                                                              • gitTool : String
                                                                                                                                                                                                                            • gitLabHookRegistration
                                                                                                                                                                                                                              • webHookMode : String
                                                                                                                                                                                                                              • systemHookMode : String
                                                                                                                                                                                                                            • gitHubIgnoreDraftPullRequestFilter
                                                                                                                                                                                                                              • ignoreOnPush
                                                                                                                                                                                                                                • jervisFilter

                                                                                                                                                                                                                                  This will look at the root of a GitHub reference for .jervis.yml for the branches and tags filtering. You can customize the name of the YAML file searched for if you like.

                                                                                                                                                                                                                                  For Tags:

                                                                                                                                                                                                                                  • It will filter for the tag name.

                                                                                                                                                                                                                                  For Branches:

                                                                                                                                                                                                                                  • It will filter for the branch name.
                                                                                                                                                                                                                                  • It will filter for pull requests destined for the branch name.

                                                                                                                                                                                                                                  Example YAML

                                                                                                                                                                                                                                  branches:
                                                                                                                                                                                                                                    only:
                                                                                                                                                                                                                                      - main
                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                  More on specify branches and tags to build

                                                                                                                                                                                                                                  By default Jervis will generate Jenkins jobs for all branches that have a .jervis.yml file. You can control and limit this behavior by specifying the branches or tags key in your .jervis.yml.

                                                                                                                                                                                                                                  Allow or block branches and tags

                                                                                                                                                                                                                                  You can either create an allow list of branches (only) or a block list of branches (except) to be built.

                                                                                                                                                                                                                                  # block branches from building
                                                                                                                                                                                                                                  branches:
                                                                                                                                                                                                                                    except:
                                                                                                                                                                                                                                      - legacy
                                                                                                                                                                                                                                      - experimental
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  # allow only these branches
                                                                                                                                                                                                                                  branches:
                                                                                                                                                                                                                                    only:
                                                                                                                                                                                                                                      - main
                                                                                                                                                                                                                                      - stable
                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                  The same YAML can be applied to tags.

                                                                                                                                                                                                                                  # block tags from building
                                                                                                                                                                                                                                  tags:
                                                                                                                                                                                                                                    except:
                                                                                                                                                                                                                                      - .*-rc
                                                                                                                                                                                                                                      - .*-beta
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  # allow only these tags
                                                                                                                                                                                                                                  tags:
                                                                                                                                                                                                                                    only:
                                                                                                                                                                                                                                      - v[.0-9]+
                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                  If you specify both only and except, then except will be ignored. .jervis.yml needs to be present on all branches you want to be built. .jervis.yml will be interpreted in the context of that branch so if you specify an allow list in your main branch, then it will not propagate to other branches.

                                                                                                                                                                                                                                  Using regular expressions

                                                                                                                                                                                                                                  You can use regular expressions to allow or block branches:

                                                                                                                                                                                                                                  branches:
                                                                                                                                                                                                                                    only:
                                                                                                                                                                                                                                      - main
                                                                                                                                                                                                                                      - /^[.0-9]+-hotfix$/
                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                  Any name surrounded with / in the list of branches is treated as a regular expression. The expression will use Pattern.compile to compile the regex string into a Groovy regular expression.

                                                                                                                                                                                                                                  • yamlFileName : String

                                                                                                                                                                                                                                    The filename which will be read from GitHub to determine if a Jenkins branch, tag, or pull request should be built. Provide a comma separated list of paths to YAML files in a repository and it will check each path as a fallback.

                                                                                                                                                                                                                                    For example, set the value to: .jervis.yml, .ci/jervis.yml and this plugin will first check for valid YAML in .jervis.yml. If no YAML exists, then it will fall back to checking .ci/jervis.yml.

                                                                                                                                                                                                                                • localBranch
                                                                                                                                                                                                                                  • logComment
                                                                                                                                                                                                                                    • logSuccess : boolean (optional)
                                                                                                                                                                                                                                      Sometimes the user doesn't want to log the builds that succeeded. The trait only enable logging of failed/aborted builds by default. Select this option to include logging of successful builds as well.
                                                                                                                                                                                                                                    • sudoUser : String (optional)
                                                                                                                                                                                                                                      Enter a sudo username of the user you want to comment as on GitLab Server. Remember the token specified should have api and sudo access both (which can only be created by your GitLab Server Admin). It is recommended to create a dummy user in your GitLab Server with an appropriate username like `jenkinsadmin` etc. Leave empty if you want use the owner of the project as the commenter.
                                                                                                                                                                                                                                  • $class: 'MercurialBrowserSCMSourceTrait'
                                                                                                                                                                                                                                    • browser
                                                                                                                                                                                                                                        Nested Choice of Objects
                                                                                                                                                                                                                                      • $class: 'FishEye'
                                                                                                                                                                                                                                        • url : String
                                                                                                                                                                                                                                          Specify the root URL serving this repository, such as: http://www.example.org/browse/hg/
                                                                                                                                                                                                                                      • $class: 'GoogleCode'
                                                                                                                                                                                                                                        • url : String
                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                      • $class: 'HgWeb'
                                                                                                                                                                                                                                        • url : String
                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                      • $class: 'Kallithea'
                                                                                                                                                                                                                                        • url : String
                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                      • $class: 'KilnHG'
                                                                                                                                                                                                                                        • url : String
                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                      • $class: 'RhodeCode'
                                                                                                                                                                                                                                        • url : String
                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                      • $class: 'RhodeCodeLegacy'
                                                                                                                                                                                                                                        • url : String
                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                      • $class: 'ScmManager'
                                                                                                                                                                                                                                        • url : String
                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as http://YOURSCMMANAGER/scm/repo/NAMESPACE/NAME/).
                                                                                                                                                                                                                                  • $class: 'MercurialInstallationSCMSourceTrait'
                                                                                                                                                                                                                                    • installation : String
                                                                                                                                                                                                                                  • multiBranchProjectDisplayNaming
                                                                                                                                                                                                                                    Some branch source plugins provide additional information about discovered branches like a title or subject of merge or change requests.
                                                                                                                                                                                                                                    With this trait, that additional information can be used for the job display names.
                                                                                                                                                                                                                                    Note: Job display name changes do not trigger builds.
                                                                                                                                                                                                                                    • displayNamingStrategy
                                                                                                                                                                                                                                      The different strategies:
                                                                                                                                                                                                                                      • Job display name with fallback to name:
                                                                                                                                                                                                                                        Uses the branch source plugin's display name for the PR instead of the raw name
                                                                                                                                                                                                                                        Value for configuration-as-code: OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                      • Name and, if available, display name:
                                                                                                                                                                                                                                        Joins the raw name and the branch source plugin's display name
                                                                                                                                                                                                                                        Value for configuration-as-code: RAW_AND_OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                      • Values: OBJECT_DISPLAY_NAME, RAW_AND_OBJECT_DISPLAY_NAME
                                                                                                                                                                                                                                  • gitHubNotificationContextTrait
                                                                                                                                                                                                                                    Defines custom context labels to be sent as part of GitHub Status notifications for this project.
                                                                                                                                                                                                                                    • contextLabel : String
                                                                                                                                                                                                                                      The text of the context label(s) for GitHub status notifications. If using multiple statuses, entries are separated by the specified delimiter.
                                                                                                                                                                                                                                    • typeSuffix : boolean

                                                                                                                                                                                                                                      Appends the relevant suffix to the context label(s) based on the build type. '/pr-merge', '/pr-head' or '/branch'

                                                                                                                                                                                                                                    • multipleStatusDelimiter : String (optional)
                                                                                                                                                                                                                                      The separator/delimiter used for splitting the Label field into multiple values.
                                                                                                                                                                                                                                    • multipleStatuses : boolean (optional)
                                                                                                                                                                                                                                      Configure multiple status notifications to be sent to GitHub.
                                                                                                                                                                                                                                  • gitLabOriginDiscovery
                                                                                                                                                                                                                                    Discovers merge requests where the origin project is the same as the target project.
                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                      Determines how merge requests are discovered:
                                                                                                                                                                                                                                      Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                      Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                      The current merge request revision
                                                                                                                                                                                                                                      Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                      Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                      Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                  • $class: 'PathBasedPullRequestFilterTrait'
                                                                                                                                                                                                                                    • inclusionField : String
                                                                                                                                                                                                                                      If any of the changed files in a discovered PR match this regex then it will generate a build (unless excluded by the exclusion regex).
                                                                                                                                                                                                                                    • exclusionField : String
                                                                                                                                                                                                                                      Any changed files in a discovered pull request that matches this regex will not be considered for the inclusion regex.
                                                                                                                                                                                                                                  • $class: 'PreBuildMergeTrait'
                                                                                                                                                                                                                                    • extension
                                                                                                                                                                                                                                        Nested Object
                                                                                                                                                                                                                                        These options allow you to perform a merge to a particular branch before building. For example, you could specify an integration branch to be built, and to merge to master. In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful. It then may push the merge back to the remote repository if the Git Push post-build action is selected.
                                                                                                                                                                                                                                      • options
                                                                                                                                                                                                                                          Nested Object
                                                                                                                                                                                                                                        • mergeTarget : String
                                                                                                                                                                                                                                          The name of the branch within the named repository to merge to, such as master.
                                                                                                                                                                                                                                        • fastForwardMode (optional)
                                                                                                                                                                                                                                          Merge fast-forward mode selection.
                                                                                                                                                                                                                                          The default, --ff, gracefully falls back to a merge commit when required.
                                                                                                                                                                                                                                          For more information, see the Git Merge Documentation
                                                                                                                                                                                                                                          • Values: FF, FF_ONLY, NO_FF
                                                                                                                                                                                                                                        • mergeRemote : String (optional)
                                                                                                                                                                                                                                          Name of the repository, such as origin, that contains the branch you specify below. If left blank, it'll default to the name of the first repository configured above.
                                                                                                                                                                                                                                        • mergeStrategy (optional)
                                                                                                                                                                                                                                          Merge strategy selection. This feature is not fully implemented in JGIT.
                                                                                                                                                                                                                                          • Values: DEFAULT, RESOLVE, RECURSIVE, OCTOPUS, OURS, SUBTREE, RECURSIVE_THEIRS
                                                                                                                                                                                                                                  • $class: 'PretestedIntegrationSCMTrait'
                                                                                                                                                                                                                                    • extension
                                                                                                                                                                                                                                        Nested Object
                                                                                                                                                                                                                                      • gitIntegrationStrategy
                                                                                                                                                                                                                                          Nested Choice of Objects
                                                                                                                                                                                                                                        • accumulated

                                                                                                                                                                                                                                          Accumulated Commit Strategy

                                                                                                                                                                                                                                          This strategy merges your commits with the --no-ff switch
                                                                                                                                                                                                                                          • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                        • ffonly

                                                                                                                                                                                                                                          Fast Forward only (--ff-only) Strategy

                                                                                                                                                                                                                                          This strategy fast-forward only using the --ff-only switch - or fails
                                                                                                                                                                                                                                          • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                        • squash

                                                                                                                                                                                                                                          Squashed Commit Strategy

                                                                                                                                                                                                                                          This strategy squashes all your commit on a given branch with the --squash option
                                                                                                                                                                                                                                        • integrationBranch : String

                                                                                                                                                                                                                                          What to specify

                                                                                                                                                                                                                                          The branch name must match your integration branch name. No trailing slash.

                                                                                                                                                                                                                                          Merge is performed the following way

                                                                                                                                                                                                                                          Squash commit
                                                                                                                                                                                                                                                      git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                      git merge --squash <Branch matched by git>
                                                                                                                                                                                                                                                      git commit -C <Branch matched by git>
                                                                                                                                                                                                                                          Accumulated commit
                                                                                                                                                                                                                                                      git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                      git merge -m <commitMsg> <Branch matched by git> --no-ff

                                                                                                                                                                                                                                          When changes are pushed to the integration branch?

                                                                                                                                                                                                                                          Changes are only ever pushed when the build results is SUCCESS

                                                                                                                                                                                                                                                      git push <Repository name> <Branch name>
                                                                                                                                                                                                                                        • repoName : String

                                                                                                                                                                                                                                          What to specify

                                                                                                                                                                                                                                          The repository name. In git the repository is always the name of the remote. So if you have specified a repository name in your Git configuration. You need to specify the exact same name here, otherwise no integration will be performed. We do the merge based on this.

                                                                                                                                                                                                                                          No trailing slash on repository name.

                                                                                                                                                                                                                                          Remember to specify this when working with NAMED repositories in Git

                                                                                                                                                                                                                                    • pruneStaleBranch
                                                                                                                                                                                                                                      • pruneStaleTag
                                                                                                                                                                                                                                        • bitbucketPublicRepoPullRequestFilter
                                                                                                                                                                                                                                          If the repository being scanned is a public repository, this behaviour will exclude all pull requests. (Note: This behaviour is not especially useful if scanning a single repository as you could just not include the pull request discovery behaviours in the first place)
                                                                                                                                                                                                                                          • $class: 'PullRequestDiscoveryTrait'
                                                                                                                                                                                                                                            • excludeBranchesWithPRs : boolean
                                                                                                                                                                                                                                              Exclude branches for which there is an open pull request
                                                                                                                                                                                                                                          • $class: 'PullRequestLabelsBlackListFilterTrait'
                                                                                                                                                                                                                                            Filter github pull requests out by labels matching any labels specified.
                                                                                                                                                                                                                                            • labels : String
                                                                                                                                                                                                                                              Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                          • $class: 'PullRequestLabelsMatchAllFilterTrait'
                                                                                                                                                                                                                                            Filter github pull requests by labels matching all labels specified.
                                                                                                                                                                                                                                            • labels : String
                                                                                                                                                                                                                                              Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                          • $class: 'PullRequestLabelsMatchAnyFilterTrait'
                                                                                                                                                                                                                                            Filter github pull requests by labels matching any labels specified.
                                                                                                                                                                                                                                            • labels : String
                                                                                                                                                                                                                                              Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                          • $class: 'PullRequestNameFilterTrait'
                                                                                                                                                                                                                                            Filter Bitbucket Pull Requests by matching in title any phrase specified.
                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                            • phrase : String
                                                                                                                                                                                                                                              Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                            • ignoreCase : boolean
                                                                                                                                                                                                                                              Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                            • regex : boolean
                                                                                                                                                                                                                                              Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                          • $class: 'PullRequestSourceBranchFilterTrait'
                                                                                                                                                                                                                                            Filter Bitbucket Pull Requests by source branch.
                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                            • phrase : String
                                                                                                                                                                                                                                              Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                            • ignoreCase : boolean
                                                                                                                                                                                                                                              Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                            • regex : boolean
                                                                                                                                                                                                                                              Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                          • $class: 'PullRequestTargetBranchFilterTrait'
                                                                                                                                                                                                                                            Filter Bitbucket Pull Requests by target branch.
                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                            • phrase : String
                                                                                                                                                                                                                                              Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                            • ignoreCase : boolean
                                                                                                                                                                                                                                              Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                            • regex : boolean
                                                                                                                                                                                                                                              Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                          • refSpecs
                                                                                                                                                                                                                                            • templates
                                                                                                                                                                                                                                                Array / List of Nested Object
                                                                                                                                                                                                                                              • value : String
                                                                                                                                                                                                                                                A ref spec to fetch. Any occurrences of @{remote} will be replaced by the remote name (which defaults to origin) before use.
                                                                                                                                                                                                                                          • headRegexFilterWithPRFromOrigin
                                                                                                                                                                                                                                            • regex : String
                                                                                                                                                                                                                                              A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                            • tagRegex : String
                                                                                                                                                                                                                                              A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                          • giteaReleaseDiscovery
                                                                                                                                                                                                                                            Discovers releases on the repository.
                                                                                                                                                                                                                                            • includePreReleases : boolean (optional)
                                                                                                                                                                                                                                              If enabled, releases that are marked as pre-release are also discovered
                                                                                                                                                                                                                                            • artifactToAssetMappingEnabled : boolean (optional)
                                                                                                                                                                                                                                              If enabled, artifacts that where archived (i.e. via archiveArtifacts) will be added as assets in the release, but only if the build was successfull.
                                                                                                                                                                                                                                          • remoteName
                                                                                                                                                                                                                                            • remoteName : String
                                                                                                                                                                                                                                          • $class: 'ScmManagerBranchDiscoveryTrait'
                                                                                                                                                                                                                                            • sparseCheckoutPaths
                                                                                                                                                                                                                                              • extension
                                                                                                                                                                                                                                                  Nested Object

                                                                                                                                                                                                                                                  Specify the paths that you'd like to sparse checkout. This may be used for saving space (Think about a reference repository). Be sure to use a recent version of Git, at least above 1.7.10

                                                                                                                                                                                                                                                • sparseCheckoutPaths
                                                                                                                                                                                                                                                    Array / List of Nested Object
                                                                                                                                                                                                                                                  • path : String
                                                                                                                                                                                                                                            • submoduleOption
                                                                                                                                                                                                                                              • extension
                                                                                                                                                                                                                                                  Nested Object
                                                                                                                                                                                                                                                • depth : int (optional)
                                                                                                                                                                                                                                                  Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                • disableSubmodules : boolean (optional)
                                                                                                                                                                                                                                                  By disabling support for submodules you can still keep using basic git plugin functionality and just have Jenkins to ignore submodules completely as if they didn't exist.
                                                                                                                                                                                                                                                • parentCredentials : boolean (optional)
                                                                                                                                                                                                                                                  Use credentials from the default remote of the parent project.
                                                                                                                                                                                                                                                • recursiveSubmodules : boolean (optional)
                                                                                                                                                                                                                                                  Retrieve all submodules recursively (uses '--recursive' option which requires git>=1.6.5)
                                                                                                                                                                                                                                                • reference : String (optional)
                                                                                                                                                                                                                                                  Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                  This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                  To prepare a reference folder with multiple subprojects, create a bare git repository and add all the remote urls then perform a fetch:
                                                                                                                                                                                                                                                    git init --bare
                                                                                                                                                                                                                                                    git remote add SubProject1 https://gitrepo.com/subproject1
                                                                                                                                                                                                                                                    git remote add SubProject2 https://gitrepo.com/subproject2
                                                                                                                                                                                                                                                    git fetch --all
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                • shallow : boolean (optional)
                                                                                                                                                                                                                                                  Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                • threads : int (optional)
                                                                                                                                                                                                                                                  Specify the number of threads that will be used to update submodules.
                                                                                                                                                                                                                                                  If unspecified, the command line git default thread count is used.
                                                                                                                                                                                                                                                • timeout : int (optional)
                                                                                                                                                                                                                                                  Specify a timeout (in minutes) for submodules operations.
                                                                                                                                                                                                                                                  This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                  You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                • trackingSubmodules : boolean (optional)
                                                                                                                                                                                                                                                  Retrieve the tip of the configured branch in .gitmodules (Uses '--remote' option which requires git>=1.8.2)
                                                                                                                                                                                                                                            • mrTriggerComment
                                                                                                                                                                                                                                              • commentBody : String
                                                                                                                                                                                                                                                Add comment body you want to use to instruct Jenkins CI to rebuild the MR
                                                                                                                                                                                                                                              • onlyTrustedMembersCanTrigger : boolean
                                                                                                                                                                                                                                            • tuleapBranchDiscovery
                                                                                                                                                                                                                                              • tuleapNotifyPullRequest
                                                                                                                                                                                                                                                • tuleapForkPullRequestDiscovery
                                                                                                                                                                                                                                                  • tuleapPullRequestDiscovery
                                                                                                                                                                                                                                                    • userIdentity
                                                                                                                                                                                                                                                      • extension
                                                                                                                                                                                                                                                          Nested Object
                                                                                                                                                                                                                                                        • name : String

                                                                                                                                                                                                                                                          If given, "GIT_COMMITTER_NAME=[this]" and "GIT_AUTHOR_NAME=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                        • email : String

                                                                                                                                                                                                                                                          If given, "GIT_COMMITTER_EMAIL=[this]" and "GIT_AUTHOR_EMAIL=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                    • bitbucketWebhookConfiguration

                                                                                                                                                                                                                                                      Sets the value for committersToIgnore in the Bitbucket Webhook. Value should be a comma separated string.

                                                                                                                                                                                                                                                      committerToIgnore is used to prevent triggering Jenkins builds when commits by certain users are made.

                                                                                                                                                                                                                                                      • committersToIgnore : String
                                                                                                                                                                                                                                                    • WebhookListenerBuildConditionsTrait
                                                                                                                                                                                                                                                      • alwaysBuildMROpen : boolean (optional)
                                                                                                                                                                                                                                                      • alwaysBuildMRReOpen : boolean (optional)
                                                                                                                                                                                                                                                      • alwaysIgnoreMRApproval : boolean (optional)
                                                                                                                                                                                                                                                      • alwaysIgnoreMRApproved : boolean (optional)
                                                                                                                                                                                                                                                      • alwaysIgnoreMRUnApproval : boolean (optional)
                                                                                                                                                                                                                                                      • alwaysIgnoreMRUnApproved : boolean (optional)
                                                                                                                                                                                                                                                      • alwaysIgnoreMRWorkInProgress : boolean (optional)
                                                                                                                                                                                                                                                      • alwaysIgnoreNonCodeRelatedUpdates : boolean (optional)
                                                                                                                                                                                                                                                        GitLab will send a webhook to Jenkins when there are updates to the MR including title changes, labels removed/added, etc. Enabling this option will prevent a build running if the cause was one of these updates. Note: these settings do not have any impact on build from comment settings.
                                                                                                                                                                                                                                                    • headWildcardFilterWithPRFromOrigin
                                                                                                                                                                                                                                                      • includes : String
                                                                                                                                                                                                                                                        Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                      • excludes : String
                                                                                                                                                                                                                                                        Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                      • tagIncludes : String
                                                                                                                                                                                                                                                        Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                      • tagExcludes : String
                                                                                                                                                                                                                                                        Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                    • $class: 'WipeWorkspaceTrait'
                                                                                                                                                                                                                                                      • bitbucketBranchDiscovery
                                                                                                                                                                                                                                                        Discovers branches on the repository.
                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                          Determines which branches are discovered.
                                                                                                                                                                                                                                                          Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                          If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                          Only branches that are also filed as PRs
                                                                                                                                                                                                                                                          Discovers branches that have PR's associated with them. This may make sense if you have a notification sent to the team at the end of a triggered build or limited Jenkins resources.
                                                                                                                                                                                                                                                          All branches
                                                                                                                                                                                                                                                          Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                      • bitbucketForkDiscovery
                                                                                                                                                                                                                                                        Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                          Determines how pull requests are discovered.
                                                                                                                                                                                                                                                          Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                          The current pull request revision
                                                                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                          Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                          Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                        • trust

                                                                                                                                                                                                                                                          One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                          Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                          Nobody
                                                                                                                                                                                                                                                          Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                          Forks in the same account
                                                                                                                                                                                                                                                          Bitbucket allows for a repository to be forked into a "sibling" repository in the same account but using a different name. This strategy will trust any pull requests from forks that are in the same account as the target repository on the basis that users have to have been granted write permission to account in order create such a fork.
                                                                                                                                                                                                                                                          Everyone
                                                                                                                                                                                                                                                          All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on Bitbucket Cloud.
                                                                                                                                                                                                                                                            Nested Choice of Objects
                                                                                                                                                                                                                                                          • bitbucketTrustEveryone
                                                                                                                                                                                                                                                            • bitbucketTrustNobody
                                                                                                                                                                                                                                                              • bitbucketTrustTeam
                                                                                                                                                                                                                                                            • bitbucketPullRequestDiscovery
                                                                                                                                                                                                                                                              Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                              • strategyId : int
                                                                                                                                                                                                                                                                Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                The current pull request revision
                                                                                                                                                                                                                                                                Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                            • bitbucketSshCheckout
                                                                                                                                                                                                                                                              By default the discovered branches / pull requests will all use the same credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                              This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                              • credentialsId : String
                                                                                                                                                                                                                                                                Credentials used to check out sources.

                                                                                                                                                                                                                                                                It must be a SSH key based credential.

                                                                                                                                                                                                                                                            • bitbucketTagDiscovery
                                                                                                                                                                                                                                                              Discovers tags on the repository.
                                                                                                                                                                                                                                                              • bitbucketWebhookRegistration

                                                                                                                                                                                                                                                                Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                • Manual webhook configuration requires the user to configure Bitbucket with the Jenkins URL in order to ensure that Bitbucket will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Bitbucket can connect to.

                                                                                                                                                                                                                                                                The Manage Jenkins » Configure Jenkins › Bitbucket Endpoints allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                • mode : String
                                                                                                                                                                                                                                                                  There are two available modes:
                                                                                                                                                                                                                                                                  Disable hook management
                                                                                                                                                                                                                                                                  Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                  Use item credentials for hook management
                                                                                                                                                                                                                                                                  Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure Jenkins › Bitbucket Endpoints
                                                                                                                                                                                                                                                              • $class: 'com.cloudogu.scmmanager.scm.BranchDiscoveryTrait'
                                                                                                                                                                                                                                                                • $class: 'com.cloudogu.scmmanager.scm.TagDiscoveryTrait'
                                                                                                                                                                                                                                                                  • dagshubBranchDiscovery
                                                                                                                                                                                                                                                                    • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.ForkPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                      • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                        If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                    • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.OriginPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                      • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                        If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                    • dagshubTagDiscovery
                                                                                                                                                                                                                                                                      • gitLabBranchDiscovery
                                                                                                                                                                                                                                                                        Discovers branches on the repository.
                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                          Determines which branches are discovered.
                                                                                                                                                                                                                                                                          Only branches that are not also filed as MRs
                                                                                                                                                                                                                                                                          If you are discovering origin merge requests, it may not make sense to discover the same changes both as a merge request and as a branch.
                                                                                                                                                                                                                                                                          Only branches that are also filed as MRs
                                                                                                                                                                                                                                                                          This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a merge request against this text.
                                                                                                                                                                                                                                                                          All branches
                                                                                                                                                                                                                                                                          Ignores whether the branch is also filed as a merge request and instead discovers all branches on the origin project.
                                                                                                                                                                                                                                                                        • branchesAlwaysIncludedRegex : String (optional)
                                                                                                                                                                                                                                                                          Regular expression of branches that should always be included regardless of whether a merge request exists or not for those branches.
                                                                                                                                                                                                                                                                      • gitLabSshCheckout
                                                                                                                                                                                                                                                                        By default the discovered branches / merge requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                        This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                        • credentialsId : String
                                                                                                                                                                                                                                                                          Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                      • gitLabTagDiscovery
                                                                                                                                                                                                                                                                        • gitBranchDiscovery
                                                                                                                                                                                                                                                                          Discovers branches on the repository.
                                                                                                                                                                                                                                                                          • gitTagDiscovery
                                                                                                                                                                                                                                                                            Discovers tags on the repository.
                                                                                                                                                                                                                                                                            • headRegexFilter
                                                                                                                                                                                                                                                                              • regex : String
                                                                                                                                                                                                                                                                                A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                            • headWildcardFilter
                                                                                                                                                                                                                                                                              • includes : String
                                                                                                                                                                                                                                                                                Space-separated list of name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                              • excludes : String
                                                                                                                                                                                                                                                                                Space-separated list of name patterns to ignore even if matched by the includes list. For example: release alpha-* beta-*
                                                                                                                                                                                                                                                                                NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                            • headRegexFilterWithPR
                                                                                                                                                                                                                                                                              • regex : String
                                                                                                                                                                                                                                                                                A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                              • tagRegex : String
                                                                                                                                                                                                                                                                                A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                            • headWildcardFilterWithPR
                                                                                                                                                                                                                                                                              • includes : String
                                                                                                                                                                                                                                                                                Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                              • excludes : String
                                                                                                                                                                                                                                                                                Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                              • tagIncludes : String
                                                                                                                                                                                                                                                                                Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                              • tagExcludes : String
                                                                                                                                                                                                                                                                                Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                            • giteaBranchDiscovery
                                                                                                                                                                                                                                                                              Discovers branches on the repository.
                                                                                                                                                                                                                                                                              • strategyId : int
                                                                                                                                                                                                                                                                                Determines which branches are discovered.
                                                                                                                                                                                                                                                                                Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a pull request against this text.
                                                                                                                                                                                                                                                                                Only branches that are also filed as PRs or main
                                                                                                                                                                                                                                                                                Discover branches that are also files as PRs (have open PRs) or that are the master / main branch.
                                                                                                                                                                                                                                                                                All branches
                                                                                                                                                                                                                                                                                Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                            • giteaForkDiscovery
                                                                                                                                                                                                                                                                              Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                              • strategyId : int
                                                                                                                                                                                                                                                                                Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                The current pull request revision
                                                                                                                                                                                                                                                                                Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                              • trust

                                                                                                                                                                                                                                                                                One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                Nobody
                                                                                                                                                                                                                                                                                Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                Contributors
                                                                                                                                                                                                                                                                                Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of contributors to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                Everyone
                                                                                                                                                                                                                                                                                All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on a Gitea instance that allows signup.
                                                                                                                                                                                                                                                                                  Nested Choice of Objects
                                                                                                                                                                                                                                                                                • gitLabTrustMembers
                                                                                                                                                                                                                                                                                  • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                    • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                      • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                        • gitLabTrustEveryone
                                                                                                                                                                                                                                                                                          • gitLabTrustNobody
                                                                                                                                                                                                                                                                                            • gitLabTrustPermissions
                                                                                                                                                                                                                                                                                              • giteaTrustContributors
                                                                                                                                                                                                                                                                                                • giteaTrustEveryone
                                                                                                                                                                                                                                                                                                  • giteaTrustNobody
                                                                                                                                                                                                                                                                                                    • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                      • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                        • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                          • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                        • giteaPullRequestDiscovery
                                                                                                                                                                                                                                                                                                          Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                            Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                            Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                            Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                            The current pull request revision
                                                                                                                                                                                                                                                                                                            Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                            Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                            Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                        • giteaSSHCheckout
                                                                                                                                                                                                                                                                                                          By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                          This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                          • credentialsId : String
                                                                                                                                                                                                                                                                                                            Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                        • giteaTagDiscovery
                                                                                                                                                                                                                                                                                                          • giteaWebhookRegistration

                                                                                                                                                                                                                                                                                                            Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                            Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                            • Manual webhook configuration requires the user to configure Gitea with the Jenkins URL in order to ensure that Gitea will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                            • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Gitea can connect to.

                                                                                                                                                                                                                                                                                                            The Manage Jenkins » Configure System › Gitea Server allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                            • mode : String
                                                                                                                                                                                                                                                                                                              There are two available modes:
                                                                                                                                                                                                                                                                                                              Disable hook management
                                                                                                                                                                                                                                                                                                              Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                              Use item credentials for hook management
                                                                                                                                                                                                                                                                                                              Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure System › Gitea Server
                                                                                                                                                                                                                                                                                                          • gitHubBranchDiscovery
                                                                                                                                                                                                                                                                                                            Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                                                                              Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                              Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                              If you are discovering origin pull requests, you may not want to also build the source branches for those pull requests.
                                                                                                                                                                                                                                                                                                              Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                              Similar to discovering origin pull requests, but discovers the branch rather than the pull request. This means env.GIT_BRANCH will be set to the branch name rather than PR-#. Also, status notifications for these builds will only be applied to the commit and not to the pull request.
                                                                                                                                                                                                                                                                                                              All branches
                                                                                                                                                                                                                                                                                                              Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                          • gitHubForkDiscovery
                                                                                                                                                                                                                                                                                                            Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                                                                              Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                              Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                              Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                              The current pull request revision
                                                                                                                                                                                                                                                                                                              Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                              Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                              Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                            • trust

                                                                                                                                                                                                                                                                                                              One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                              Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                              Nobody
                                                                                                                                                                                                                                                                                                              Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                              Collaborators
                                                                                                                                                                                                                                                                                                              Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of collaborators to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody. NOTE: all collaborators are trusted, even if they are only members of a team with read permission.
                                                                                                                                                                                                                                                                                                              Everyone
                                                                                                                                                                                                                                                                                                              All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on GitHub.
                                                                                                                                                                                                                                                                                                              From users with Admin or Write permission
                                                                                                                                                                                                                                                                                                              Pull requests forks will be treated as trusted if and only if the fork owner has either Admin or Write permissions on the origin repository. This is the recommended policy. Note that this strategy requires the Review a user's permission level API, as a result on GitHub Enterprise Server versions before 2.12 this is the same as trusting Nobody.
                                                                                                                                                                                                                                                                                                                Nested Choice of Objects
                                                                                                                                                                                                                                                                                                              • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                  • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                    • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                  • gitHubPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                    Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                      Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                      Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                      The current pull request revision
                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                      Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                      Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                  • gitHubSshCheckout
                                                                                                                                                                                                                                                                                                                    By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                    This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                    • credentialsId : String
                                                                                                                                                                                                                                                                                                                      Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                  • gitHubTagDiscovery
                                                                                                                                                                                                                                                                                                                    Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                • gitblit
                                                                                                                                                                                                                                                                                                                  • gitblitUri : String
                                                                                                                                                                                                                                                                                                                  • checkoutCredentialsId : String
                                                                                                                                                                                                                                                                                                                  • scanCredentialsId : String
                                                                                                                                                                                                                                                                                                                  • remote : String
                                                                                                                                                                                                                                                                                                                    Specify the URL of this remote repository. This uses the same syntax as your git clone command.
                                                                                                                                                                                                                                                                                                                  • includes : String
                                                                                                                                                                                                                                                                                                                  • excludes : String
                                                                                                                                                                                                                                                                                                                  • id : String (optional)
                                                                                                                                                                                                                                                                                                                  • browser (optional)
                                                                                                                                                                                                                                                                                                                      Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                    • assembla
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                    • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                      • repoName : String
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                    • bitbucketServer
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                        Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                    • bitbucket
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                    • cgit
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                    • fisheye
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                        Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                    • gitblit
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                      • projectName : String
                                                                                                                                                                                                                                                                                                                        Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                    • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                      • url : String
                                                                                                                                                                                                                                                                                                                    • gitLab
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                      • version : String (optional)
                                                                                                                                                                                                                                                                                                                        Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                    • gitLabBrowser
                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                      • projectUrl : String
                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                    • gitList
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                    • gitWeb
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                    • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                    • github
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                    • gitiles
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                    • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                    • gogs
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                    • kiln
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                    • phabricator
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                        Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                      • repo : String
                                                                                                                                                                                                                                                                                                                        Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                    • redmine
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                    • rhodeCode
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                    • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                    • jbSpace
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                        Provide the absolute URL to your repository in JetBrains SpaceCode in the following format: https://<your SpaceCode instance>/p/<project key>/repositories/<repository name>
                                                                                                                                                                                                                                                                                                                    • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                    • teamFoundation
                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                        Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                        If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                    • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                      • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                        Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                        • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                          The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                      • viewgit
                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                        • projectName : String
                                                                                                                                                                                                                                                                                                                          Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                    • credentialsId : String (optional)
                                                                                                                                                                                                                                                                                                                      Credentials used to scan branches and check out sources.
                                                                                                                                                                                                                                                                                                                    • extensions (optional)
                                                                                                                                                                                                                                                                                                                        Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                      • authorInChangelog
                                                                                                                                                                                                                                                                                                                        The default behavior is to use the Git commit's "Committer" value in Jenkins' build changesets. If this option is selected, the Git commit's "Author" value would be used instead.
                                                                                                                                                                                                                                                                                                                        • $class: 'BuildChooserSetting'
                                                                                                                                                                                                                                                                                                                          When you are interested in using a job to build multiple heads (most typically multiple branches), you can choose how Jenkins choose what branches to build in what order.

                                                                                                                                                                                                                                                                                                                          This extension point in Jenkins is used by many other plugins to control the job to build specific commits. When you activate those plugins, you may see them installing a custom strategy here.

                                                                                                                                                                                                                                                                                                                          • buildChooser
                                                                                                                                                                                                                                                                                                                              Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                            • $class: 'AlternativeBuildChooser'
                                                                                                                                                                                                                                                                                                                              • $class: 'AncestryBuildChooser'
                                                                                                                                                                                                                                                                                                                                • maximumAgeInDays : int
                                                                                                                                                                                                                                                                                                                                • ancestorCommitSha1 : String
                                                                                                                                                                                                                                                                                                                              • $class: 'DefaultBuildChooser'
                                                                                                                                                                                                                                                                                                                                • $class: 'DeflakeGitBuildChooser'
                                                                                                                                                                                                                                                                                                                                  • $class: 'GerritTriggerBuildChooser'
                                                                                                                                                                                                                                                                                                                                    • $class: 'InverseBuildChooser'
                                                                                                                                                                                                                                                                                                                                  • buildSingleRevisionOnly
                                                                                                                                                                                                                                                                                                                                    Disable scheduling for multiple candidate revisions.
                                                                                                                                                                                                                                                                                                                                    If we have 3 branches:
                                                                                                                                                                                                                                                                                                                                    ----A--.---.--- B
                                                                                                                                                                                                                                                                                                                                             \-----C
                                                                                                                                                                                                                                                                                                                                    jenkins would try to build (B) and (C).
                                                                                                                                                                                                                                                                                                                                    This behaviour disables this and only builds one of them.
                                                                                                                                                                                                                                                                                                                                    It is helpful to reduce the load of the Jenkins infrastructure when the SCM system like Bitbucket or GitHub should decide what commits to build.
                                                                                                                                                                                                                                                                                                                                    • changelogToBranch
                                                                                                                                                                                                                                                                                                                                      This method calculates the changelog against the specified branch.
                                                                                                                                                                                                                                                                                                                                      • options
                                                                                                                                                                                                                                                                                                                                          Nested Object
                                                                                                                                                                                                                                                                                                                                        • compareRemote : String
                                                                                                                                                                                                                                                                                                                                          Name of the repository, such as origin, that contains the branch you specify below.
                                                                                                                                                                                                                                                                                                                                        • compareTarget : String
                                                                                                                                                                                                                                                                                                                                          The name of the branch within the named repository to compare against.
                                                                                                                                                                                                                                                                                                                                    • checkoutOption
                                                                                                                                                                                                                                                                                                                                      • timeout : int
                                                                                                                                                                                                                                                                                                                                        Specify a timeout (in minutes) for checkout.
                                                                                                                                                                                                                                                                                                                                        This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                        You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                    • cleanBeforeCheckout
                                                                                                                                                                                                                                                                                                                                      Clean up the workspace before every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                      • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                        Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                    • cleanAfterCheckout
                                                                                                                                                                                                                                                                                                                                      Clean up the workspace after every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                      • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                        Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                    • cloneOption
                                                                                                                                                                                                                                                                                                                                      • shallow : boolean
                                                                                                                                                                                                                                                                                                                                        Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                      • noTags : boolean
                                                                                                                                                                                                                                                                                                                                        Deselect this to perform a clone without tags, saving time and disk space when you just want to access what is specified by the refspec.
                                                                                                                                                                                                                                                                                                                                      • reference : String
                                                                                                                                                                                                                                                                                                                                        Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                        This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                      • timeout : int
                                                                                                                                                                                                                                                                                                                                        Specify a timeout (in minutes) for clone and fetch operations.
                                                                                                                                                                                                                                                                                                                                        This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                        You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                      • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                        Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                      • honorRefspec : boolean (optional)
                                                                                                                                                                                                                                                                                                                                        Perform initial clone using the refspec defined for the repository. This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
                                                                                                                                                                                                                                                                                                                                    • $class: 'CodeCommitURLHelper'
                                                                                                                                                                                                                                                                                                                                      • credentialId : String

                                                                                                                                                                                                                                                                                                                                        OPTIONAL: Select the credentials to use.
                                                                                                                                                                                                                                                                                                                                        If not specified, defaults to the DefaultAWSCredentialsProviderChain behaviour - *FROM THE JENKINS INSTANCE*

                                                                                                                                                                                                                                                                                                                                        In the latter case, usage of IAM Role Profiles seems not to work, thus relying on environment variables / system properties or the ~/.aws/credentials file, thus not recommended.

                                                                                                                                                                                                                                                                                                                                      • repositoryName : String
                                                                                                                                                                                                                                                                                                                                    • $class: 'DisableRemotePoll'
                                                                                                                                                                                                                                                                                                                                      Git plugin uses git ls-remote polling mechanism by default when configured with a single branch (no wildcards!). This compare the latest built commit SHA with the remote branch without cloning a local copy of the repo.

                                                                                                                                                                                                                                                                                                                                      If you don't want to / can't use this.

                                                                                                                                                                                                                                                                                                                                      If this option is selected, polling will require a workspace and might trigger unwanted builds (see JENKINS-10131).
                                                                                                                                                                                                                                                                                                                                      • $class: 'ExcludeFromChangeSet'
                                                                                                                                                                                                                                                                                                                                        • $class: 'ExcludeFromPoll'
                                                                                                                                                                                                                                                                                                                                          • lfs
                                                                                                                                                                                                                                                                                                                                            Enable git large file support for the workspace by pulling large files after the checkout completes. Requires that the controller and each agent performing an LFS checkout have installed `git lfs`.
                                                                                                                                                                                                                                                                                                                                            • $class: 'GitSCMChecksExtension'
                                                                                                                                                                                                                                                                                                                                              • verboseConsoleLog : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                If this option is checked, verbose log will be output to build console; the verbose log is useful for debugging the publisher creation.
                                                                                                                                                                                                                                                                                                                                            • $class: 'GitSCMStatusChecksExtension'
                                                                                                                                                                                                                                                                                                                                              • name : String (optional)
                                                                                                                                                                                                                                                                                                                                              • skip : boolean (optional)
                                                                                                                                                                                                                                                                                                                                              • skipProgressUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                              • suppressLogs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                              • unstableBuildNeutral : boolean (optional)
                                                                                                                                                                                                                                                                                                                                            • $class: 'GitTagMessageExtension'
                                                                                                                                                                                                                                                                                                                                              If the revision checked out has a git tag associated with it, the tag name will be exported during the build as GIT_TAG_NAME.
                                                                                                                                                                                                                                                                                                                                              If a message was specified when creating the tag, then that message will be exported during the build as the GIT_TAG_MESSAGE environment variable.
                                                                                                                                                                                                                                                                                                                                              If no tag message was specified, the commit message will be used.
                                                                                                                                                                                                                                                                                                                                              If you ticked the Use most recent tag option, and the revision checked out has no git tag associated with it, the parent commits will be searched for a git tag, and the rules stated above will apply to the first parent commit with a git tag.

                                                                                                                                                                                                                                                                                                                                              If the revision has more than one tag associated with it, only the most recent tag will be taken into account, unless the refspec contains "refs/tags/" — i.e. builds are only triggered when certain tag names or patterns are matched — in which case the exact tag name that triggered the build will be used, even if it's not the most recent tag for this commit.
                                                                                                                                                                                                                                                                                                                                              For this reason, if you're not using a tag-specific refspec but you are using the "Create a tag for every build" behaviour, you should make sure that the build-tagging behaviour is configured to run after this "export git tag message" behaviour.

                                                                                                                                                                                                                                                                                                                                              Tag and commit messages which span multiple lines are no problem, though only the first 10000 lines of a tag's message will be exported.
                                                                                                                                                                                                                                                                                                                                              • useMostRecentTag : boolean (optional)
                                                                                                                                                                                                                                                                                                                                            • $class: 'IgnoreNotifyCommit'
                                                                                                                                                                                                                                                                                                                                              If checked, this repository will be ignored when the notifyCommit-URL is accessed regardless of if the repository matches or not.
                                                                                                                                                                                                                                                                                                                                              • localBranch
                                                                                                                                                                                                                                                                                                                                                If given, checkout the revision to build as HEAD on this branch.

                                                                                                                                                                                                                                                                                                                                                If selected, and its value is an empty string or "**", then the branch name is computed from the remote branch without the origin. In that case, a remote branch origin/master will be checked out to a local branch named master, and a remote branch origin/develop/new-feature will be checked out to a local branch named develop/newfeature.

                                                                                                                                                                                                                                                                                                                                                Please note that this has not been tested with submodules.

                                                                                                                                                                                                                                                                                                                                                • localBranch : String
                                                                                                                                                                                                                                                                                                                                              • $class: 'MessageExclusion'
                                                                                                                                                                                                                                                                                                                                                • excludedMessage : String
                                                                                                                                                                                                                                                                                                                                                  If set, and Jenkins is set to poll for changes, Jenkins will ignore any revisions committed with message matched to Pattern when determining if a build needs to be triggered. This can be used to exclude commits done by the build itself from triggering another build, assuming the build server commits the change with a distinct message.

                                                                                                                                                                                                                                                                                                                                                  Exclusion uses Pattern matching

                                                                                                                                                                                                                                                                                                                                                  .*\[maven-release-plugin\].*
                                                                                                                                                                                                                                                                                                                                                  The example above illustrates that if only revisions with "[maven-release-plugin]" message in first comment line have been committed to the SCM a build will not occur.

                                                                                                                                                                                                                                                                                                                                                  You can create more complex patterns using embedded flag expressions.
                                                                                                                                                                                                                                                                                                                                                  (?s).*FOO.*
                                                                                                                                                                                                                                                                                                                                                  This example will search FOO message in all comment lines.
                                                                                                                                                                                                                                                                                                                                              • $class: 'PathRestriction'
                                                                                                                                                                                                                                                                                                                                                If set, and Jenkins is set to poll for changes, Jenkins will pay attention to included and/or excluded files and/or folders when determining if a build needs to be triggered.

                                                                                                                                                                                                                                                                                                                                                Using this behaviour will preclude the faster git ls-remote polling mechanism, forcing polling to require a workspace thus sometimes triggering unwanted builds, as if you had selected the Force polling using workspace extension as well.
                                                                                                                                                                                                                                                                                                                                                • includedRegions : String
                                                                                                                                                                                                                                                                                                                                                  Each inclusion uses java regular expression pattern matching, and must be separated by a new line. An empty list implies that everything is included.

                                                                                                                                                                                                                                                                                                                                                      myapp/src/main/web/.*\.html
                                                                                                                                                                                                                                                                                                                                                      myapp/src/main/web/.*\.jpeg
                                                                                                                                                                                                                                                                                                                                                      myapp/src/main/web/.*\.gif
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                  The example above illustrates that a build will only occur, if html/jpeg/gif files have been committed to the SCM. Exclusions take precedence over inclusions, if there is an overlap between included and excluded regions.
                                                                                                                                                                                                                                                                                                                                                • excludedRegions : String
                                                                                                                                                                                                                                                                                                                                                  Each exclusion uses java regular expression pattern matching, and must be separated by a new line.

                                                                                                                                                                                                                                                                                                                                                      myapp/src/main/web/.*\.html
                                                                                                                                                                                                                                                                                                                                                      myapp/src/main/web/.*\.jpeg
                                                                                                                                                                                                                                                                                                                                                      myapp/src/main/web/.*\.gif
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                  The example above illustrates that if only html/jpeg/gif files have been committed to the SCM a build will not occur.
                                                                                                                                                                                                                                                                                                                                              • perBuildTag
                                                                                                                                                                                                                                                                                                                                                Create a tag in the workspace for every build to unambiguously mark the commit that was built. You can combine this with Git publisher to push the tags to the remote repository.
                                                                                                                                                                                                                                                                                                                                                • $class: 'PreBuildMerge'
                                                                                                                                                                                                                                                                                                                                                  These options allow you to perform a merge to a particular branch before building. For example, you could specify an integration branch to be built, and to merge to master. In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful. It then may push the merge back to the remote repository if the Git Push post-build action is selected.
                                                                                                                                                                                                                                                                                                                                                  • options
                                                                                                                                                                                                                                                                                                                                                      Nested Object
                                                                                                                                                                                                                                                                                                                                                    • mergeTarget : String
                                                                                                                                                                                                                                                                                                                                                      The name of the branch within the named repository to merge to, such as master.
                                                                                                                                                                                                                                                                                                                                                    • fastForwardMode (optional)
                                                                                                                                                                                                                                                                                                                                                      Merge fast-forward mode selection.
                                                                                                                                                                                                                                                                                                                                                      The default, --ff, gracefully falls back to a merge commit when required.
                                                                                                                                                                                                                                                                                                                                                      For more information, see the Git Merge Documentation
                                                                                                                                                                                                                                                                                                                                                      • Values: FF, FF_ONLY, NO_FF
                                                                                                                                                                                                                                                                                                                                                    • mergeRemote : String (optional)
                                                                                                                                                                                                                                                                                                                                                      Name of the repository, such as origin, that contains the branch you specify below. If left blank, it'll default to the name of the first repository configured above.
                                                                                                                                                                                                                                                                                                                                                    • mergeStrategy (optional)
                                                                                                                                                                                                                                                                                                                                                      Merge strategy selection. This feature is not fully implemented in JGIT.
                                                                                                                                                                                                                                                                                                                                                      • Values: DEFAULT, RESOLVE, RECURSIVE, OCTOPUS, OURS, SUBTREE, RECURSIVE_THEIRS
                                                                                                                                                                                                                                                                                                                                                • pretestedIntegration
                                                                                                                                                                                                                                                                                                                                                  • gitIntegrationStrategy
                                                                                                                                                                                                                                                                                                                                                      Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                    • accumulated

                                                                                                                                                                                                                                                                                                                                                      Accumulated Commit Strategy

                                                                                                                                                                                                                                                                                                                                                      This strategy merges your commits with the --no-ff switch
                                                                                                                                                                                                                                                                                                                                                      • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                    • ffonly

                                                                                                                                                                                                                                                                                                                                                      Fast Forward only (--ff-only) Strategy

                                                                                                                                                                                                                                                                                                                                                      This strategy fast-forward only using the --ff-only switch - or fails
                                                                                                                                                                                                                                                                                                                                                      • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                    • squash

                                                                                                                                                                                                                                                                                                                                                      Squashed Commit Strategy

                                                                                                                                                                                                                                                                                                                                                      This strategy squashes all your commit on a given branch with the --squash option
                                                                                                                                                                                                                                                                                                                                                    • integrationBranch : String

                                                                                                                                                                                                                                                                                                                                                      What to specify

                                                                                                                                                                                                                                                                                                                                                      The branch name must match your integration branch name. No trailing slash.

                                                                                                                                                                                                                                                                                                                                                      Merge is performed the following way

                                                                                                                                                                                                                                                                                                                                                      Squash commit
                                                                                                                                                                                                                                                                                                                                                                  git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                  git merge --squash <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                  git commit -C <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                      Accumulated commit
                                                                                                                                                                                                                                                                                                                                                                  git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                  git merge -m <commitMsg> <Branch matched by git> --no-ff

                                                                                                                                                                                                                                                                                                                                                      When changes are pushed to the integration branch?

                                                                                                                                                                                                                                                                                                                                                      Changes are only ever pushed when the build results is SUCCESS

                                                                                                                                                                                                                                                                                                                                                                  git push <Repository name> <Branch name>
                                                                                                                                                                                                                                                                                                                                                    • repoName : String

                                                                                                                                                                                                                                                                                                                                                      What to specify

                                                                                                                                                                                                                                                                                                                                                      The repository name. In git the repository is always the name of the remote. So if you have specified a repository name in your Git configuration. You need to specify the exact same name here, otherwise no integration will be performed. We do the merge based on this.

                                                                                                                                                                                                                                                                                                                                                      No trailing slash on repository name.

                                                                                                                                                                                                                                                                                                                                                      Remember to specify this when working with NAMED repositories in Git

                                                                                                                                                                                                                                                                                                                                                  • pruneStaleBranch
                                                                                                                                                                                                                                                                                                                                                    Run "git remote prune" for each remote, to prune obsolete local branches.
                                                                                                                                                                                                                                                                                                                                                    • pruneTags
                                                                                                                                                                                                                                                                                                                                                      • pruneTags : boolean
                                                                                                                                                                                                                                                                                                                                                    • $class: 'RelativeTargetDirectory'
                                                                                                                                                                                                                                                                                                                                                      • relativeTargetDir : String
                                                                                                                                                                                                                                                                                                                                                        Specify a local directory (relative to the workspace root) where the Git repository will be checked out. If left empty, the workspace root itself will be used.

                                                                                                                                                                                                                                                                                                                                                        This extension should not be used in Jenkins Pipeline (either declarative or scripted). Jenkins Pipeline already provides standard techniques for checkout to a subdirectory. Use ws and dir in Jenkins Pipeline rather than this extension.

                                                                                                                                                                                                                                                                                                                                                    • $class: 'ScmName'

                                                                                                                                                                                                                                                                                                                                                      Unique name for this SCM. Needed when using Git within the Multi SCM plugin.

                                                                                                                                                                                                                                                                                                                                                      • name : String
                                                                                                                                                                                                                                                                                                                                                    • $class: 'SparseCheckoutPaths'

                                                                                                                                                                                                                                                                                                                                                      Specify the paths that you'd like to sparse checkout. This may be used for saving space (Think about a reference repository). Be sure to use a recent version of Git, at least above 1.7.10

                                                                                                                                                                                                                                                                                                                                                      • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                          Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                        • path : String
                                                                                                                                                                                                                                                                                                                                                    • submodule
                                                                                                                                                                                                                                                                                                                                                      • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                        Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                      • disableSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                        By disabling support for submodules you can still keep using basic git plugin functionality and just have Jenkins to ignore submodules completely as if they didn't exist.
                                                                                                                                                                                                                                                                                                                                                      • parentCredentials : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                        Use credentials from the default remote of the parent project.
                                                                                                                                                                                                                                                                                                                                                      • recursiveSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                        Retrieve all submodules recursively (uses '--recursive' option which requires git>=1.6.5)
                                                                                                                                                                                                                                                                                                                                                      • reference : String (optional)
                                                                                                                                                                                                                                                                                                                                                        Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                        This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                        To prepare a reference folder with multiple subprojects, create a bare git repository and add all the remote urls then perform a fetch:
                                                                                                                                                                                                                                                                                                                                                          git init --bare
                                                                                                                                                                                                                                                                                                                                                          git remote add SubProject1 https://gitrepo.com/subproject1
                                                                                                                                                                                                                                                                                                                                                          git remote add SubProject2 https://gitrepo.com/subproject2
                                                                                                                                                                                                                                                                                                                                                          git fetch --all
                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                      • shallow : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                        Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                      • threads : int (optional)
                                                                                                                                                                                                                                                                                                                                                        Specify the number of threads that will be used to update submodules.
                                                                                                                                                                                                                                                                                                                                                        If unspecified, the command line git default thread count is used.
                                                                                                                                                                                                                                                                                                                                                      • timeout : int (optional)
                                                                                                                                                                                                                                                                                                                                                        Specify a timeout (in minutes) for submodules operations.
                                                                                                                                                                                                                                                                                                                                                        This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                        You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                      • trackingSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                        Retrieve the tip of the configured branch in .gitmodules (Uses '--remote' option which requires git>=1.8.2)
                                                                                                                                                                                                                                                                                                                                                    • $class: 'UserExclusion'
                                                                                                                                                                                                                                                                                                                                                      • excludedUsers : String
                                                                                                                                                                                                                                                                                                                                                        If set, and Jenkins is set to poll for changes, Jenkins will ignore any revisions committed by users in this list when determining if a build needs to be triggered. This can be used to exclude commits done by the build itself from triggering another build, assuming the build server commits the change with a distinct SCM user.

                                                                                                                                                                                                                                                                                                                                                        Using this behaviour will preclude the faster git ls-remote polling mechanism, forcing polling to require a workspace thus sometimes triggering unwanted builds, as if you had selected the Force polling using workspace extension as well.

                                                                                                                                                                                                                                                                                                                                                        Each exclusion uses exact string comparison and must be separated by a new line. User names are only excluded if they exactly match one of the names in this list.

                                                                                                                                                                                                                                                                                                                                                        auto_build_user
                                                                                                                                                                                                                                                                                                                                                        The example above illustrates that if only revisions by "auto_build_user" have been committed to the SCM a build will not occur.
                                                                                                                                                                                                                                                                                                                                                    • $class: 'UserIdentity'
                                                                                                                                                                                                                                                                                                                                                      • name : String

                                                                                                                                                                                                                                                                                                                                                        If given, "GIT_COMMITTER_NAME=[this]" and "GIT_AUTHOR_NAME=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                      • email : String

                                                                                                                                                                                                                                                                                                                                                        If given, "GIT_COMMITTER_EMAIL=[this]" and "GIT_AUTHOR_EMAIL=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                    • $class: 'WipeWorkspace'
                                                                                                                                                                                                                                                                                                                                                      Delete the contents of the workspace before building, ensuring a fully fresh workspace.
                                                                                                                                                                                                                                                                                                                                                    • gitTool : String (optional)
                                                                                                                                                                                                                                                                                                                                                    • traits (optional)
                                                                                                                                                                                                                                                                                                                                                        Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                      • $class: 'ApprovedPullRequestTrait'
                                                                                                                                                                                                                                                                                                                                                        Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                          Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                          No approval necessary.
                                                                                                                                                                                                                                                                                                                                                          No check of approvals will be performed before building.
                                                                                                                                                                                                                                                                                                                                                          Any approval required
                                                                                                                                                                                                                                                                                                                                                          Before building the pull request must be approved. This may be performed by the author or someone else.
                                                                                                                                                                                                                                                                                                                                                          Non-author approval required
                                                                                                                                                                                                                                                                                                                                                          Before building the pull request must be approved and that approval cannot be performed by the author of the pull request.
                                                                                                                                                                                                                                                                                                                                                          Author and Non-author approval required
                                                                                                                                                                                                                                                                                                                                                          Before building the pull request must be approved by the author and a non-author.
                                                                                                                                                                                                                                                                                                                                                      • authorInChangelog
                                                                                                                                                                                                                                                                                                                                                        • bitbucketAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                          Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                          • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                        • bitbucketBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                          Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                          • $class: 'BitbucketBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                            Discovers branches in the repository.
                                                                                                                                                                                                                                                                                                                                                            • bitbucketBuildStatusNotifications
                                                                                                                                                                                                                                                                                                                                                              Configure the Bitbucket notifications.
                                                                                                                                                                                                                                                                                                                                                              • disableNotificationForNotBuildJobs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                              • sendSuccessNotificationForUnstableBuild : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                            • bitbucketCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                              Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                              • $class: 'BitbucketGitBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                • browser
                                                                                                                                                                                                                                                                                                                                                                    Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                  • assembla
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                  • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                    • repoName : String
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                  • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                  • bitbucket
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                  • cgit
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                  • fisheye
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                  • gitblit
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                    • projectName : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                  • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                    • url : String
                                                                                                                                                                                                                                                                                                                                                                  • gitLab
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                    • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                      Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                  • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                    Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                    • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                  • gitList
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                  • gitWeb
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                  • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                  • github
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                  • gitiles
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                  • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                  • gogs
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                  • kiln
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                  • phabricator
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                    • repo : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                  • redmine
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                  • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                  • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                  • jbSpace
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Provide the absolute URL to your repository in JetBrains SpaceCode in the following format: https://<your SpaceCode instance>/p/<project key>/repositories/<repository name>
                                                                                                                                                                                                                                                                                                                                                                  • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                  • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                      Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                      If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                  • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                    • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                      • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                        The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                    • viewgit
                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                      • projectName : String
                                                                                                                                                                                                                                                                                                                                                                        Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                • $class: 'BitbucketJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                  Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                  • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                • $class: 'BitbucketPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                  Discovers open pull requests in the repository.
                                                                                                                                                                                                                                                                                                                                                                  • buildStatusNameCustomPart
                                                                                                                                                                                                                                                                                                                                                                    Customize the pipeline status name used by Jenkins
                                                                                                                                                                                                                                                                                                                                                                    • buildStatusNameCustomPart : String (optional)
                                                                                                                                                                                                                                                                                                                                                                      Enter a string to customize the status/context name for status updates published to GitLab. For a branch build the default name would be 'jenkinsci/branch'. With the buildStatusNameCustomPart 'custom' the name would be 'jenkinsci/custom/branch'. This allows to have multiple GitLab-Branch-Sources for the same GitLab-project configured.
                                                                                                                                                                                                                                                                                                                                                                    • buildStatusNameOverwrite : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                      Overwrites the build status name including the jenkinsci default part.
                                                                                                                                                                                                                                                                                                                                                                      Instead of 'jenkinsci/custom/branch' just 'custom/branch'.
                                                                                                                                                                                                                                                                                                                                                                    • ignoreTypeInStatusName : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                  • $class: 'ChangeDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                    • queryString : String

                                                                                                                                                                                                                                                                                                                                                                      Provide an additional query string to search for open changes. The status:open is implicitly added and does not need to be specified. See Gerrit search operators documentation for a detailed list of the supported search operators.

                                                                                                                                                                                                                                                                                                                                                                      Examples:

                                                                                                                                                                                                                                                                                                                                                                      • -is:wip
                                                                                                                                                                                                                                                                                                                                                                        does not include work-in-progress changes
                                                                                                                                                                                                                                                                                                                                                                      • is:private
                                                                                                                                                                                                                                                                                                                                                                        includes private changes

                                                                                                                                                                                                                                                                                                                                                                  • checkoutOption
                                                                                                                                                                                                                                                                                                                                                                    • extension
                                                                                                                                                                                                                                                                                                                                                                        Nested Object
                                                                                                                                                                                                                                                                                                                                                                      • timeout : int
                                                                                                                                                                                                                                                                                                                                                                        Specify a timeout (in minutes) for checkout.
                                                                                                                                                                                                                                                                                                                                                                        This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                        You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                  • cleanAfterCheckout
                                                                                                                                                                                                                                                                                                                                                                    • extension
                                                                                                                                                                                                                                                                                                                                                                        Nested Object
                                                                                                                                                                                                                                                                                                                                                                        Clean up the workspace after every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                      • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                        Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                  • cleanBeforeCheckout
                                                                                                                                                                                                                                                                                                                                                                    • extension
                                                                                                                                                                                                                                                                                                                                                                        Nested Object
                                                                                                                                                                                                                                                                                                                                                                        Clean up the workspace before every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                      • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                        Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                  • $class: 'CleanMercurialSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                    When this behaviour is present, each build will wipe any local modifications or untracked files in the repository checkout. This is often a convenient way to ensure that a build is not using any artifacts from earlier builds.
                                                                                                                                                                                                                                                                                                                                                                    • cloneOption
                                                                                                                                                                                                                                                                                                                                                                      • extension
                                                                                                                                                                                                                                                                                                                                                                          Nested Object
                                                                                                                                                                                                                                                                                                                                                                        • shallow : boolean
                                                                                                                                                                                                                                                                                                                                                                          Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                        • noTags : boolean
                                                                                                                                                                                                                                                                                                                                                                          Deselect this to perform a clone without tags, saving time and disk space when you just want to access what is specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                        • reference : String
                                                                                                                                                                                                                                                                                                                                                                          Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                          This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                        • timeout : int
                                                                                                                                                                                                                                                                                                                                                                          Specify a timeout (in minutes) for clone and fetch operations.
                                                                                                                                                                                                                                                                                                                                                                          This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                          You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                        • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                          Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                        • honorRefspec : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                          Perform initial clone using the refspec defined for the repository. This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                    • $class: 'DisableStatusUpdateTrait'
                                                                                                                                                                                                                                                                                                                                                                      Disables notifications (commit status updates) to GitHub for builds.
                                                                                                                                                                                                                                                                                                                                                                      • discoverOtherRefs
                                                                                                                                                                                                                                                                                                                                                                        Discovers other specified refs on the repository.
                                                                                                                                                                                                                                                                                                                                                                        • ref : String

                                                                                                                                                                                                                                                                                                                                                                          The pattern under /refs on the remote repository to discover, can contain a wildcard.
                                                                                                                                                                                                                                                                                                                                                                          Example: test/*/merged

                                                                                                                                                                                                                                                                                                                                                                        • nameMapping : String (optional)

                                                                                                                                                                                                                                                                                                                                                                          Mapping for how the ref can be named in for example the @Library.
                                                                                                                                                                                                                                                                                                                                                                          Example: test-@{1}
                                                                                                                                                                                                                                                                                                                                                                          Where @{1} replaces the first wildcard in the ref when discovered.

                                                                                                                                                                                                                                                                                                                                                                          By default it will be "namespace_before_wildcard-@{1}". E.g. if ref is "test/*/merged" the default mapping would be "test-@{1}".

                                                                                                                                                                                                                                                                                                                                                                      • $class: 'FilterChecksTrait'
                                                                                                                                                                                                                                                                                                                                                                        • queryOperator
                                                                                                                                                                                                                                                                                                                                                                          • Values: ID, SCHEME
                                                                                                                                                                                                                                                                                                                                                                        • queryString : String
                                                                                                                                                                                                                                                                                                                                                                          Provide a query string to search for pending checks. Depending on which mode was chosen, this either should be a checker-scheme or the UUID of a specific checker.
                                                                                                                                                                                                                                                                                                                                                                      • gitLabForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                        Discovers merge requests where the origin project is a fork of the target project.
                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                          Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                          Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                          Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                          The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                          Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                          Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                          Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                        • trust

                                                                                                                                                                                                                                                                                                                                                                          One of the great powers of merge requests is that anyone with read access to a project can fork it, commit some changes to their fork and then create a merge request against the original project with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox merge requests in order to mitigate against malicious merge requests. In order to protect against a malicious merge request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for merge requests from forks.

                                                                                                                                                                                                                                                                                                                                                                          Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                          Nobody
                                                                                                                                                                                                                                                                                                                                                                          Merge requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin project and not from the merge request branch on the fork project.
                                                                                                                                                                                                                                                                                                                                                                          Members
                                                                                                                                                                                                                                                                                                                                                                          Merge requests from collaborators to the origin project will be treated as trusted, all other merge requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the project does not have permission to query the list of contributors to the origin project then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                          Trusted Members
                                                                                                                                                                                                                                                                                                                                                                          Merge requests forks will be treated as trusted if and only if the fork owner has either Developer or Maintainer or Owner Access Level in the origin project. This is the recommended policy.
                                                                                                                                                                                                                                                                                                                                                                          Everyone
                                                                                                                                                                                                                                                                                                                                                                          All merge requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public project hosted on a GitLab instance.
                                                                                                                                                                                                                                                                                                                                                                          • Type: jenkins.scm.api.trait.SCMHeadAuthority<? super io.jenkins.plugins.gitlabbranchsource.GitLabSCMSourceRequest, ? extends jenkins.scm.api.mixin.ChangeRequestSCMHead2, ? extends jenkins.scm.api.SCMRevision>
                                                                                                                                                                                                                                                                                                                                                                        • buildMRForksNotMirror : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                          Add discovery of merge requests where the origin project is a fork of a certain project, but the target project is not the original forked project. To be used in case one has a GitLab project which is a fork of another project from another team, in order to isolate artefacts and allow an MR flow. This means using MRs inside that fork from branches in the fork back to the fork's default branch. (Implements https://github.com/jenkinsci/gitlab-branch-source-plugin/issues/167)
                                                                                                                                                                                                                                                                                                                                                                      • browser
                                                                                                                                                                                                                                                                                                                                                                        • browser
                                                                                                                                                                                                                                                                                                                                                                            Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                          • assembla
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                          • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                            • repoName : String
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                          • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                          • bitbucket
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                          • cgit
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                          • fisheye
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                          • gitblit
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                            • projectName : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                          • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                            • url : String
                                                                                                                                                                                                                                                                                                                                                                          • gitLab
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                            • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                              Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                          • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                            Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                            • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                          • gitList
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                          • gitWeb
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                          • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                          • github
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                          • gitiles
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                          • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                          • gogs
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                          • kiln
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                          • phabricator
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                            • repo : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                          • redmine
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                          • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                          • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                          • jbSpace
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Provide the absolute URL to your repository in JetBrains SpaceCode in the following format: https://<your SpaceCode instance>/p/<project key>/repositories/<repository name>
                                                                                                                                                                                                                                                                                                                                                                          • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                          • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                              Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                              If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                          • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                            • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                              • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                            • viewgit
                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                              • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                        • gitHubAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                                          Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                                          • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                                        • gitHubBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                          Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                          • gitHubCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                            Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                            • $class: 'GitHubJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                              Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                              • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                            • gitHubSourceChecks
                                                                                                                                                                                                                                                                                                                                                                              • verboseConsoleLog : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                If this option is checked, verbose log will be output to build console; the verbose log is useful for debugging the publisher creation.
                                                                                                                                                                                                                                                                                                                                                                            • gitHubStatusChecks
                                                                                                                                                                                                                                                                                                                                                                              • name : String (optional)
                                                                                                                                                                                                                                                                                                                                                                              • skip : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                              • skipNotifications : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                If this option is checked, the notifications sent by the GitHub Branch Source Plugin will be disabled.
                                                                                                                                                                                                                                                                                                                                                                              • skipProgressUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                              • suppressLogs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                              • unstableBuildNeutral : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                            • lfs
                                                                                                                                                                                                                                                                                                                                                                              • gitlabAvatar
                                                                                                                                                                                                                                                                                                                                                                                • disableProjectAvatar : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                  Due to a GitLab bug, sometimes it is not possible to GitLab API to fetch GitLab Avatar for private projects or when the api doesn't have token access. You may choose to skip avatar for projects if you want to avoid broken or self generated avatars.
                                                                                                                                                                                                                                                                                                                                                                              • gitlabMarkUnstableAsSuccess
                                                                                                                                                                                                                                                                                                                                                                                • markUnstableAsSuccess : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                              • gitlabSkipNotifications
                                                                                                                                                                                                                                                                                                                                                                                • gitTool
                                                                                                                                                                                                                                                                                                                                                                                  • gitTool : String
                                                                                                                                                                                                                                                                                                                                                                                • gitLabHookRegistration
                                                                                                                                                                                                                                                                                                                                                                                  • webHookMode : String
                                                                                                                                                                                                                                                                                                                                                                                  • systemHookMode : String
                                                                                                                                                                                                                                                                                                                                                                                • gitHubIgnoreDraftPullRequestFilter
                                                                                                                                                                                                                                                                                                                                                                                  • ignoreOnPush
                                                                                                                                                                                                                                                                                                                                                                                    • jervisFilter

                                                                                                                                                                                                                                                                                                                                                                                      This will look at the root of a GitHub reference for .jervis.yml for the branches and tags filtering. You can customize the name of the YAML file searched for if you like.

                                                                                                                                                                                                                                                                                                                                                                                      For Tags:

                                                                                                                                                                                                                                                                                                                                                                                      • It will filter for the tag name.

                                                                                                                                                                                                                                                                                                                                                                                      For Branches:

                                                                                                                                                                                                                                                                                                                                                                                      • It will filter for the branch name.
                                                                                                                                                                                                                                                                                                                                                                                      • It will filter for pull requests destined for the branch name.

                                                                                                                                                                                                                                                                                                                                                                                      Example YAML

                                                                                                                                                                                                                                                                                                                                                                                      branches:
                                                                                                                                                                                                                                                                                                                                                                                        only:
                                                                                                                                                                                                                                                                                                                                                                                          - main
                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                      More on specify branches and tags to build

                                                                                                                                                                                                                                                                                                                                                                                      By default Jervis will generate Jenkins jobs for all branches that have a .jervis.yml file. You can control and limit this behavior by specifying the branches or tags key in your .jervis.yml.

                                                                                                                                                                                                                                                                                                                                                                                      Allow or block branches and tags

                                                                                                                                                                                                                                                                                                                                                                                      You can either create an allow list of branches (only) or a block list of branches (except) to be built.

                                                                                                                                                                                                                                                                                                                                                                                      # block branches from building
                                                                                                                                                                                                                                                                                                                                                                                      branches:
                                                                                                                                                                                                                                                                                                                                                                                        except:
                                                                                                                                                                                                                                                                                                                                                                                          - legacy
                                                                                                                                                                                                                                                                                                                                                                                          - experimental
                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                      # allow only these branches
                                                                                                                                                                                                                                                                                                                                                                                      branches:
                                                                                                                                                                                                                                                                                                                                                                                        only:
                                                                                                                                                                                                                                                                                                                                                                                          - main
                                                                                                                                                                                                                                                                                                                                                                                          - stable
                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                      The same YAML can be applied to tags.

                                                                                                                                                                                                                                                                                                                                                                                      # block tags from building
                                                                                                                                                                                                                                                                                                                                                                                      tags:
                                                                                                                                                                                                                                                                                                                                                                                        except:
                                                                                                                                                                                                                                                                                                                                                                                          - .*-rc
                                                                                                                                                                                                                                                                                                                                                                                          - .*-beta
                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                      # allow only these tags
                                                                                                                                                                                                                                                                                                                                                                                      tags:
                                                                                                                                                                                                                                                                                                                                                                                        only:
                                                                                                                                                                                                                                                                                                                                                                                          - v[.0-9]+
                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                      If you specify both only and except, then except will be ignored. .jervis.yml needs to be present on all branches you want to be built. .jervis.yml will be interpreted in the context of that branch so if you specify an allow list in your main branch, then it will not propagate to other branches.

                                                                                                                                                                                                                                                                                                                                                                                      Using regular expressions

                                                                                                                                                                                                                                                                                                                                                                                      You can use regular expressions to allow or block branches:

                                                                                                                                                                                                                                                                                                                                                                                      branches:
                                                                                                                                                                                                                                                                                                                                                                                        only:
                                                                                                                                                                                                                                                                                                                                                                                          - main
                                                                                                                                                                                                                                                                                                                                                                                          - /^[.0-9]+-hotfix$/
                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                      Any name surrounded with / in the list of branches is treated as a regular expression. The expression will use Pattern.compile to compile the regex string into a Groovy regular expression.

                                                                                                                                                                                                                                                                                                                                                                                      • yamlFileName : String

                                                                                                                                                                                                                                                                                                                                                                                        The filename which will be read from GitHub to determine if a Jenkins branch, tag, or pull request should be built. Provide a comma separated list of paths to YAML files in a repository and it will check each path as a fallback.

                                                                                                                                                                                                                                                                                                                                                                                        For example, set the value to: .jervis.yml, .ci/jervis.yml and this plugin will first check for valid YAML in .jervis.yml. If no YAML exists, then it will fall back to checking .ci/jervis.yml.

                                                                                                                                                                                                                                                                                                                                                                                    • localBranch
                                                                                                                                                                                                                                                                                                                                                                                      • logComment
                                                                                                                                                                                                                                                                                                                                                                                        • logSuccess : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                          Sometimes the user doesn't want to log the builds that succeeded. The trait only enable logging of failed/aborted builds by default. Select this option to include logging of successful builds as well.
                                                                                                                                                                                                                                                                                                                                                                                        • sudoUser : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                          Enter a sudo username of the user you want to comment as on GitLab Server. Remember the token specified should have api and sudo access both (which can only be created by your GitLab Server Admin). It is recommended to create a dummy user in your GitLab Server with an appropriate username like `jenkinsadmin` etc. Leave empty if you want use the owner of the project as the commenter.
                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'MercurialBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                        • browser
                                                                                                                                                                                                                                                                                                                                                                                            Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'FishEye'
                                                                                                                                                                                                                                                                                                                                                                                            • url : String
                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository, such as: http://www.example.org/browse/hg/
                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'GoogleCode'
                                                                                                                                                                                                                                                                                                                                                                                            • url : String
                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'HgWeb'
                                                                                                                                                                                                                                                                                                                                                                                            • url : String
                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'Kallithea'
                                                                                                                                                                                                                                                                                                                                                                                            • url : String
                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'KilnHG'
                                                                                                                                                                                                                                                                                                                                                                                            • url : String
                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'RhodeCode'
                                                                                                                                                                                                                                                                                                                                                                                            • url : String
                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'RhodeCodeLegacy'
                                                                                                                                                                                                                                                                                                                                                                                            • url : String
                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'ScmManager'
                                                                                                                                                                                                                                                                                                                                                                                            • url : String
                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as http://YOURSCMMANAGER/scm/repo/NAMESPACE/NAME/).
                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'MercurialInstallationSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                        • installation : String
                                                                                                                                                                                                                                                                                                                                                                                      • multiBranchProjectDisplayNaming
                                                                                                                                                                                                                                                                                                                                                                                        Some branch source plugins provide additional information about discovered branches like a title or subject of merge or change requests.
                                                                                                                                                                                                                                                                                                                                                                                        With this trait, that additional information can be used for the job display names.
                                                                                                                                                                                                                                                                                                                                                                                        Note: Job display name changes do not trigger builds.
                                                                                                                                                                                                                                                                                                                                                                                        • displayNamingStrategy
                                                                                                                                                                                                                                                                                                                                                                                          The different strategies:
                                                                                                                                                                                                                                                                                                                                                                                          • Job display name with fallback to name:
                                                                                                                                                                                                                                                                                                                                                                                            Uses the branch source plugin's display name for the PR instead of the raw name
                                                                                                                                                                                                                                                                                                                                                                                            Value for configuration-as-code: OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                                                                                                                                          • Name and, if available, display name:
                                                                                                                                                                                                                                                                                                                                                                                            Joins the raw name and the branch source plugin's display name
                                                                                                                                                                                                                                                                                                                                                                                            Value for configuration-as-code: RAW_AND_OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                                                                                                                                          • Values: OBJECT_DISPLAY_NAME, RAW_AND_OBJECT_DISPLAY_NAME
                                                                                                                                                                                                                                                                                                                                                                                      • gitHubNotificationContextTrait
                                                                                                                                                                                                                                                                                                                                                                                        Defines custom context labels to be sent as part of GitHub Status notifications for this project.
                                                                                                                                                                                                                                                                                                                                                                                        • contextLabel : String
                                                                                                                                                                                                                                                                                                                                                                                          The text of the context label(s) for GitHub status notifications. If using multiple statuses, entries are separated by the specified delimiter.
                                                                                                                                                                                                                                                                                                                                                                                        • typeSuffix : boolean

                                                                                                                                                                                                                                                                                                                                                                                          Appends the relevant suffix to the context label(s) based on the build type. '/pr-merge', '/pr-head' or '/branch'

                                                                                                                                                                                                                                                                                                                                                                                        • multipleStatusDelimiter : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                          The separator/delimiter used for splitting the Label field into multiple values.
                                                                                                                                                                                                                                                                                                                                                                                        • multipleStatuses : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                          Configure multiple status notifications to be sent to GitHub.
                                                                                                                                                                                                                                                                                                                                                                                      • gitLabOriginDiscovery
                                                                                                                                                                                                                                                                                                                                                                                        Discovers merge requests where the origin project is the same as the target project.
                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                          Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                          Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                          Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                          The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                                          Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                          Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                          Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'PathBasedPullRequestFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                        • inclusionField : String
                                                                                                                                                                                                                                                                                                                                                                                          If any of the changed files in a discovered PR match this regex then it will generate a build (unless excluded by the exclusion regex).
                                                                                                                                                                                                                                                                                                                                                                                        • exclusionField : String
                                                                                                                                                                                                                                                                                                                                                                                          Any changed files in a discovered pull request that matches this regex will not be considered for the inclusion regex.
                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'PreBuildMergeTrait'
                                                                                                                                                                                                                                                                                                                                                                                        • extension
                                                                                                                                                                                                                                                                                                                                                                                            Nested Object
                                                                                                                                                                                                                                                                                                                                                                                            These options allow you to perform a merge to a particular branch before building. For example, you could specify an integration branch to be built, and to merge to master. In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful. It then may push the merge back to the remote repository if the Git Push post-build action is selected.
                                                                                                                                                                                                                                                                                                                                                                                          • options
                                                                                                                                                                                                                                                                                                                                                                                              Nested Object
                                                                                                                                                                                                                                                                                                                                                                                            • mergeTarget : String
                                                                                                                                                                                                                                                                                                                                                                                              The name of the branch within the named repository to merge to, such as master.
                                                                                                                                                                                                                                                                                                                                                                                            • fastForwardMode (optional)
                                                                                                                                                                                                                                                                                                                                                                                              Merge fast-forward mode selection.
                                                                                                                                                                                                                                                                                                                                                                                              The default, --ff, gracefully falls back to a merge commit when required.
                                                                                                                                                                                                                                                                                                                                                                                              For more information, see the Git Merge Documentation
                                                                                                                                                                                                                                                                                                                                                                                              • Values: FF, FF_ONLY, NO_FF
                                                                                                                                                                                                                                                                                                                                                                                            • mergeRemote : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                              Name of the repository, such as origin, that contains the branch you specify below. If left blank, it'll default to the name of the first repository configured above.
                                                                                                                                                                                                                                                                                                                                                                                            • mergeStrategy (optional)
                                                                                                                                                                                                                                                                                                                                                                                              Merge strategy selection. This feature is not fully implemented in JGIT.
                                                                                                                                                                                                                                                                                                                                                                                              • Values: DEFAULT, RESOLVE, RECURSIVE, OCTOPUS, OURS, SUBTREE, RECURSIVE_THEIRS
                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'PretestedIntegrationSCMTrait'
                                                                                                                                                                                                                                                                                                                                                                                        • extension
                                                                                                                                                                                                                                                                                                                                                                                            Nested Object
                                                                                                                                                                                                                                                                                                                                                                                          • gitIntegrationStrategy
                                                                                                                                                                                                                                                                                                                                                                                              Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                            • accumulated

                                                                                                                                                                                                                                                                                                                                                                                              Accumulated Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                              This strategy merges your commits with the --no-ff switch
                                                                                                                                                                                                                                                                                                                                                                                              • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                            • ffonly

                                                                                                                                                                                                                                                                                                                                                                                              Fast Forward only (--ff-only) Strategy

                                                                                                                                                                                                                                                                                                                                                                                              This strategy fast-forward only using the --ff-only switch - or fails
                                                                                                                                                                                                                                                                                                                                                                                              • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                            • squash

                                                                                                                                                                                                                                                                                                                                                                                              Squashed Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                              This strategy squashes all your commit on a given branch with the --squash option
                                                                                                                                                                                                                                                                                                                                                                                            • integrationBranch : String

                                                                                                                                                                                                                                                                                                                                                                                              What to specify

                                                                                                                                                                                                                                                                                                                                                                                              The branch name must match your integration branch name. No trailing slash.

                                                                                                                                                                                                                                                                                                                                                                                              Merge is performed the following way

                                                                                                                                                                                                                                                                                                                                                                                              Squash commit
                                                                                                                                                                                                                                                                                                                                                                                                          git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                          git merge --squash <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                          git commit -C <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                              Accumulated commit
                                                                                                                                                                                                                                                                                                                                                                                                          git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                          git merge -m <commitMsg> <Branch matched by git> --no-ff

                                                                                                                                                                                                                                                                                                                                                                                              When changes are pushed to the integration branch?

                                                                                                                                                                                                                                                                                                                                                                                              Changes are only ever pushed when the build results is SUCCESS

                                                                                                                                                                                                                                                                                                                                                                                                          git push <Repository name> <Branch name>
                                                                                                                                                                                                                                                                                                                                                                                            • repoName : String

                                                                                                                                                                                                                                                                                                                                                                                              What to specify

                                                                                                                                                                                                                                                                                                                                                                                              The repository name. In git the repository is always the name of the remote. So if you have specified a repository name in your Git configuration. You need to specify the exact same name here, otherwise no integration will be performed. We do the merge based on this.

                                                                                                                                                                                                                                                                                                                                                                                              No trailing slash on repository name.

                                                                                                                                                                                                                                                                                                                                                                                              Remember to specify this when working with NAMED repositories in Git

                                                                                                                                                                                                                                                                                                                                                                                        • pruneStaleBranch
                                                                                                                                                                                                                                                                                                                                                                                          • pruneStaleTag
                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketPublicRepoPullRequestFilter
                                                                                                                                                                                                                                                                                                                                                                                              If the repository being scanned is a public repository, this behaviour will exclude all pull requests. (Note: This behaviour is not especially useful if scanning a single repository as you could just not include the pull request discovery behaviours in the first place)
                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'PullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                • excludeBranchesWithPRs : boolean
                                                                                                                                                                                                                                                                                                                                                                                                  Exclude branches for which there is an open pull request
                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'PullRequestLabelsBlackListFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                Filter github pull requests out by labels matching any labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                  Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'PullRequestLabelsMatchAllFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                Filter github pull requests by labels matching all labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                  Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'PullRequestLabelsMatchAnyFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                Filter github pull requests by labels matching any labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                  Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'PullRequestNameFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                Filter Bitbucket Pull Requests by matching in title any phrase specified.
                                                                                                                                                                                                                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                  Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                  Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                  Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'PullRequestSourceBranchFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                Filter Bitbucket Pull Requests by source branch.
                                                                                                                                                                                                                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                  Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                  Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                  Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'PullRequestTargetBranchFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                Filter Bitbucket Pull Requests by target branch.
                                                                                                                                                                                                                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                  Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                  Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                  Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                              • refSpecs
                                                                                                                                                                                                                                                                                                                                                                                                • templates
                                                                                                                                                                                                                                                                                                                                                                                                    Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                  • value : String
                                                                                                                                                                                                                                                                                                                                                                                                    A ref spec to fetch. Any occurrences of @{remote} will be replaced by the remote name (which defaults to origin) before use.
                                                                                                                                                                                                                                                                                                                                                                                              • headRegexFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                                                                                                                                • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                  A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                • tagRegex : String
                                                                                                                                                                                                                                                                                                                                                                                                  A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                              • giteaReleaseDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                Discovers releases on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                • includePreReleases : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                  If enabled, releases that are marked as pre-release are also discovered
                                                                                                                                                                                                                                                                                                                                                                                                • artifactToAssetMappingEnabled : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                  If enabled, artifacts that where archived (i.e. via archiveArtifacts) will be added as assets in the release, but only if the build was successfull.
                                                                                                                                                                                                                                                                                                                                                                                              • remoteName
                                                                                                                                                                                                                                                                                                                                                                                                • remoteName : String
                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'ScmManagerBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                  • extension
                                                                                                                                                                                                                                                                                                                                                                                                      Nested Object

                                                                                                                                                                                                                                                                                                                                                                                                      Specify the paths that you'd like to sparse checkout. This may be used for saving space (Think about a reference repository). Be sure to use a recent version of Git, at least above 1.7.10

                                                                                                                                                                                                                                                                                                                                                                                                    • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                        Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                      • path : String
                                                                                                                                                                                                                                                                                                                                                                                                • submoduleOption
                                                                                                                                                                                                                                                                                                                                                                                                  • extension
                                                                                                                                                                                                                                                                                                                                                                                                      Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                    • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                      Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                    • disableSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                      By disabling support for submodules you can still keep using basic git plugin functionality and just have Jenkins to ignore submodules completely as if they didn't exist.
                                                                                                                                                                                                                                                                                                                                                                                                    • parentCredentials : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                      Use credentials from the default remote of the parent project.
                                                                                                                                                                                                                                                                                                                                                                                                    • recursiveSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                      Retrieve all submodules recursively (uses '--recursive' option which requires git>=1.6.5)
                                                                                                                                                                                                                                                                                                                                                                                                    • reference : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                      Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                      This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                      To prepare a reference folder with multiple subprojects, create a bare git repository and add all the remote urls then perform a fetch:
                                                                                                                                                                                                                                                                                                                                                                                                        git init --bare
                                                                                                                                                                                                                                                                                                                                                                                                        git remote add SubProject1 https://gitrepo.com/subproject1
                                                                                                                                                                                                                                                                                                                                                                                                        git remote add SubProject2 https://gitrepo.com/subproject2
                                                                                                                                                                                                                                                                                                                                                                                                        git fetch --all
                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                    • shallow : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                      Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                    • threads : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                      Specify the number of threads that will be used to update submodules.
                                                                                                                                                                                                                                                                                                                                                                                                      If unspecified, the command line git default thread count is used.
                                                                                                                                                                                                                                                                                                                                                                                                    • timeout : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                      Specify a timeout (in minutes) for submodules operations.
                                                                                                                                                                                                                                                                                                                                                                                                      This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                      You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                    • trackingSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                      Retrieve the tip of the configured branch in .gitmodules (Uses '--remote' option which requires git>=1.8.2)
                                                                                                                                                                                                                                                                                                                                                                                                • mrTriggerComment
                                                                                                                                                                                                                                                                                                                                                                                                  • commentBody : String
                                                                                                                                                                                                                                                                                                                                                                                                    Add comment body you want to use to instruct Jenkins CI to rebuild the MR
                                                                                                                                                                                                                                                                                                                                                                                                  • onlyTrustedMembersCanTrigger : boolean
                                                                                                                                                                                                                                                                                                                                                                                                • tuleapBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                  • tuleapNotifyPullRequest
                                                                                                                                                                                                                                                                                                                                                                                                    • tuleapForkPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                      • tuleapPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                        • userIdentity
                                                                                                                                                                                                                                                                                                                                                                                                          • extension
                                                                                                                                                                                                                                                                                                                                                                                                              Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                            • name : String

                                                                                                                                                                                                                                                                                                                                                                                                              If given, "GIT_COMMITTER_NAME=[this]" and "GIT_AUTHOR_NAME=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                            • email : String

                                                                                                                                                                                                                                                                                                                                                                                                              If given, "GIT_COMMITTER_EMAIL=[this]" and "GIT_AUTHOR_EMAIL=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketWebhookConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                          Sets the value for committersToIgnore in the Bitbucket Webhook. Value should be a comma separated string.

                                                                                                                                                                                                                                                                                                                                                                                                          committerToIgnore is used to prevent triggering Jenkins builds when commits by certain users are made.

                                                                                                                                                                                                                                                                                                                                                                                                          • committersToIgnore : String
                                                                                                                                                                                                                                                                                                                                                                                                        • WebhookListenerBuildConditionsTrait
                                                                                                                                                                                                                                                                                                                                                                                                          • alwaysBuildMROpen : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                          • alwaysBuildMRReOpen : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                          • alwaysIgnoreMRApproval : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                          • alwaysIgnoreMRApproved : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                          • alwaysIgnoreMRUnApproval : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                          • alwaysIgnoreMRUnApproved : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                          • alwaysIgnoreMRWorkInProgress : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                          • alwaysIgnoreNonCodeRelatedUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                            GitLab will send a webhook to Jenkins when there are updates to the MR including title changes, labels removed/added, etc. Enabling this option will prevent a build running if the cause was one of these updates. Note: these settings do not have any impact on build from comment settings.
                                                                                                                                                                                                                                                                                                                                                                                                        • headWildcardFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                                                                                                                                          • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                            Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                          • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                            Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                                                                                                          • tagIncludes : String
                                                                                                                                                                                                                                                                                                                                                                                                            Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                                                                                                          • tagExcludes : String
                                                                                                                                                                                                                                                                                                                                                                                                            Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'WipeWorkspaceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                            Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                              Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                              Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                              If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                              Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                              Discovers branches that have PR's associated with them. This may make sense if you have a notification sent to the team at the end of a triggered build or limited Jenkins resources.
                                                                                                                                                                                                                                                                                                                                                                                                              All branches
                                                                                                                                                                                                                                                                                                                                                                                                              Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                            Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                              Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                              Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                              Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                              The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                              Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                              Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                              Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                            • trust

                                                                                                                                                                                                                                                                                                                                                                                                              One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                              Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                              Nobody
                                                                                                                                                                                                                                                                                                                                                                                                              Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                              Forks in the same account
                                                                                                                                                                                                                                                                                                                                                                                                              Bitbucket allows for a repository to be forked into a "sibling" repository in the same account but using a different name. This strategy will trust any pull requests from forks that are in the same account as the target repository on the basis that users have to have been granted write permission to account in order create such a fork.
                                                                                                                                                                                                                                                                                                                                                                                                              Everyone
                                                                                                                                                                                                                                                                                                                                                                                                              All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on Bitbucket Cloud.
                                                                                                                                                                                                                                                                                                                                                                                                                Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                    Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                    Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                    The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                    Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                  By default the discovered branches / pull requests will all use the same credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                  This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                  • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                    Credentials used to check out sources.

                                                                                                                                                                                                                                                                                                                                                                                                                    It must be a SSH key based credential.

                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                                                                                    Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                                                                                    Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                                                                                    • Manual webhook configuration requires the user to configure Bitbucket with the Jenkins URL in order to ensure that Bitbucket will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                                                                                    • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Bitbucket can connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                    The Manage Jenkins » Configure Jenkins › Bitbucket Endpoints allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                                                                                    • mode : String
                                                                                                                                                                                                                                                                                                                                                                                                                      There are two available modes:
                                                                                                                                                                                                                                                                                                                                                                                                                      Disable hook management
                                                                                                                                                                                                                                                                                                                                                                                                                      Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                      Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                                                                                      Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure Jenkins › Bitbucket Endpoints
                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'com.cloudogu.scmmanager.scm.BranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'com.cloudogu.scmmanager.scm.TagDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                      • dagshubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.ForkPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                          • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                            If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.OriginPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                          • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                            If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                                                                                                                                        • dagshubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                          • gitLabBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                            Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                              Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                              Only branches that are not also filed as MRs
                                                                                                                                                                                                                                                                                                                                                                                                                              If you are discovering origin merge requests, it may not make sense to discover the same changes both as a merge request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                              Only branches that are also filed as MRs
                                                                                                                                                                                                                                                                                                                                                                                                                              This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a merge request against this text.
                                                                                                                                                                                                                                                                                                                                                                                                                              All branches
                                                                                                                                                                                                                                                                                                                                                                                                                              Ignores whether the branch is also filed as a merge request and instead discovers all branches on the origin project.
                                                                                                                                                                                                                                                                                                                                                                                                                            • branchesAlwaysIncludedRegex : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                              Regular expression of branches that should always be included regardless of whether a merge request exists or not for those branches.
                                                                                                                                                                                                                                                                                                                                                                                                                          • gitLabSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                            By default the discovered branches / merge requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                            This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                            • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                              Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                          • gitLabTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                            • gitBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                              • gitTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                • headRegexFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                  • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                    A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                • headWildcardFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                  • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                    Space-separated list of name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                  • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                    Space-separated list of name patterns to ignore even if matched by the includes list. For example: release alpha-* beta-*
                                                                                                                                                                                                                                                                                                                                                                                                                                    NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                • headRegexFilterWithPR
                                                                                                                                                                                                                                                                                                                                                                                                                                  • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                    A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                  • tagRegex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                    A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                • headWildcardFilterWithPR
                                                                                                                                                                                                                                                                                                                                                                                                                                  • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                    Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                  • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                    Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                                                                                                                                  • tagIncludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                    Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                  • tagExcludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                    Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                                                                                                                                • giteaBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                    Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                    Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                    This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a pull request against this text.
                                                                                                                                                                                                                                                                                                                                                                                                                                    Only branches that are also filed as PRs or main
                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover branches that are also files as PRs (have open PRs) or that are the master / main branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                    All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                    Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                • giteaForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                    Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                    The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                    Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                  • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                    One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                    Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                    Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                    Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                    Contributors
                                                                                                                                                                                                                                                                                                                                                                                                                                    Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of contributors to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                    Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                    All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on a Gitea instance that allows signup.
                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitLabTrustMembers
                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitLabTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitLabTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitLabTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • giteaTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • giteaTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • giteaTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • giteaPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • giteaSSHCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                              By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • giteaTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • giteaWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Manual webhook configuration requires the user to configure Gitea with the Jenkins URL in order to ensure that Gitea will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Gitea can connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                The Manage Jenkins » Configure System › Gitea Server allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                • mode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  There are two available modes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Disable hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure System › Gitea Server
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If you are discovering origin pull requests, you may not want to also build the source branches for those pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Similar to discovering origin pull requests, but discovers the branch rather than the pull request. This means env.GIT_BRANCH will be set to the branch name rather than PR-#. Also, status notifications for these builds will only be applied to the commit and not to the pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Collaborators
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of collaborators to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody. NOTE: all collaborators are trusted, even if they are only members of a team with read permission.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on GitHub.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  From users with Admin or Write permission
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Pull requests forks will be treated as trusted if and only if the fork owner has either Admin or Write permissions on the origin repository. This is the recommended policy. Note that this strategy requires the Review a user's permission level API, as a result on GitHub Enterprise Server versions before 2.12 this is the same as trusting Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitHubPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitHubSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitHubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitlab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • serverName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Select the GitLab Server where you want the projects to be discovered from.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • projectOwner : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the namespace which owns your projects. It can be a user, a group or a subgroup with full path. E.g: If you want projects from subgroup `a` inside group `b`, then `Owner` should be b/a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • projectPath : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Select the project on which you want to perform the Multibranch Pipeline Job.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • credentialsId : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Checkout credentials is only needed for private projects. Add `SSHPrivateKey` or `Username/Password` to checkout over SSH remote or HTTPS remote respectively.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • id : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • projectId : long (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • traits (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'ApprovedPullRequestTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            No approval necessary.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            No check of approvals will be performed before building.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Any approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Before building the pull request must be approved. This may be performed by the author or someone else.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Non-author approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Before building the pull request must be approved and that approval cannot be performed by the author of the pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Author and Non-author approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Before building the pull request must be approved by the author and a non-author.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • authorInChangelog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'BitbucketBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers branches in the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketBuildStatusNotifications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Configure the Bitbucket notifications.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • disableNotificationForNotBuildJobs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • sendSuccessNotificationForUnstableBuild : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'BitbucketGitBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • assembla
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • cgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • fisheye
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitblit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitLab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • kiln
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • phabricator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repo : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • redmine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • jbSpace
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Provide the absolute URL to your repository in JetBrains SpaceCode in the following format: https://<your SpaceCode instance>/p/<project key>/repositories/<repository name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • viewgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'BitbucketJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'BitbucketPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers open pull requests in the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • buildStatusNameCustomPart
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Customize the pipeline status name used by Jenkins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • buildStatusNameCustomPart : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enter a string to customize the status/context name for status updates published to GitLab. For a branch build the default name would be 'jenkinsci/branch'. With the buildStatusNameCustomPart 'custom' the name would be 'jenkinsci/custom/branch'. This allows to have multiple GitLab-Branch-Sources for the same GitLab-project configured.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • buildStatusNameOverwrite : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Overwrites the build status name including the jenkinsci default part.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Instead of 'jenkinsci/custom/branch' just 'custom/branch'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ignoreTypeInStatusName : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'ChangeDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • queryString : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Provide an additional query string to search for open changes. The status:open is implicitly added and does not need to be specified. See Gerrit search operators documentation for a detailed list of the supported search operators.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Examples:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • -is:wip
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          does not include work-in-progress changes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • is:private
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          includes private changes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • checkoutOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify a timeout (in minutes) for checkout.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • cleanAfterCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Clean up the workspace after every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • cleanBeforeCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Clean up the workspace before every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'CleanMercurialSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      When this behaviour is present, each build will wipe any local modifications or untracked files in the repository checkout. This is often a convenient way to ensure that a build is not using any artifacts from earlier builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • cloneOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • shallow : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • noTags : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Deselect this to perform a clone without tags, saving time and disk space when you just want to access what is specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • reference : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify a timeout (in minutes) for clone and fetch operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • honorRefspec : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Perform initial clone using the refspec defined for the repository. This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'DisableStatusUpdateTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Disables notifications (commit status updates) to GitHub for builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • discoverOtherRefs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers other specified refs on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • ref : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The pattern under /refs on the remote repository to discover, can contain a wildcard.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Example: test/*/merged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • nameMapping : String (optional)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Mapping for how the ref can be named in for example the @Library.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Example: test-@{1}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Where @{1} replaces the first wildcard in the ref when discovered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            By default it will be "namespace_before_wildcard-@{1}". E.g. if ref is "test/*/merged" the default mapping would be "test-@{1}".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'FilterChecksTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • queryOperator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Values: ID, SCHEME
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • queryString : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Provide a query string to search for pending checks. Depending on which mode was chosen, this either should be a checker-scheme or the UUID of a specific checker.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitLabForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers merge requests where the origin project is a fork of the target project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            One of the great powers of merge requests is that anyone with read access to a project can fork it, commit some changes to their fork and then create a merge request against the original project with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox merge requests in order to mitigate against malicious merge requests. In order to protect against a malicious merge request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for merge requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Merge requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin project and not from the merge request branch on the fork project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Members
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Merge requests from collaborators to the origin project will be treated as trusted, all other merge requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the project does not have permission to query the list of contributors to the origin project then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Trusted Members
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Merge requests forks will be treated as trusted if and only if the fork owner has either Developer or Maintainer or Owner Access Level in the origin project. This is the recommended policy.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            All merge requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public project hosted on a GitLab instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Type: jenkins.scm.api.trait.SCMHeadAuthority<? super io.jenkins.plugins.gitlabbranchsource.GitLabSCMSourceRequest, ? extends jenkins.scm.api.mixin.ChangeRequestSCMHead2, ? extends jenkins.scm.api.SCMRevision>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • buildMRForksNotMirror : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Add discovery of merge requests where the origin project is a fork of a certain project, but the target project is not the original forked project. To be used in case one has a GitLab project which is a fork of another project from another team, in order to isolate artefacts and allow an MR flow. This means using MRs inside that fork from branches in the fork back to the fork's default branch. (Implements https://github.com/jenkinsci/gitlab-branch-source-plugin/issues/167)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • assembla
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • cgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • fisheye
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitblit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitLab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • kiln
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • phabricator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repo : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • redmine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • jbSpace
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Provide the absolute URL to your repository in JetBrains SpaceCode in the following format: https://<your SpaceCode instance>/p/<project key>/repositories/<repository name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • viewgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'GitHubJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubSourceChecks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • verboseConsoleLog : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If this option is checked, verbose log will be output to build console; the verbose log is useful for debugging the publisher creation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubStatusChecks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • name : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • skip : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • skipNotifications : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If this option is checked, the notifications sent by the GitHub Branch Source Plugin will be disabled.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • skipProgressUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • suppressLogs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • unstableBuildNeutral : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • lfs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitlabAvatar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • disableProjectAvatar : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Due to a GitLab bug, sometimes it is not possible to GitLab API to fetch GitLab Avatar for private projects or when the api doesn't have token access. You may choose to skip avatar for projects if you want to avoid broken or self generated avatars.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitlabMarkUnstableAsSuccess
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • markUnstableAsSuccess : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitlabSkipNotifications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitTool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitTool : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitLabHookRegistration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • webHookMode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • systemHookMode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubIgnoreDraftPullRequestFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ignoreOnPush
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • jervisFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This will look at the root of a GitHub reference for .jervis.yml for the branches and tags filtering. You can customize the name of the YAML file searched for if you like.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For Tags:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • It will filter for the tag name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For Branches:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • It will filter for the branch name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • It will filter for pull requests destined for the branch name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Example YAML

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        More on specify branches and tags to build

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        By default Jervis will generate Jenkins jobs for all branches that have a .jervis.yml file. You can control and limit this behavior by specifying the branches or tags key in your .jervis.yml.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Allow or block branches and tags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You can either create an allow list of branches (only) or a block list of branches (except) to be built.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        # block branches from building
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          except:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - legacy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - experimental
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        # allow only these branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - stable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The same YAML can be applied to tags.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        # block tags from building
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tags:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          except:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - .*-rc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - .*-beta
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        # allow only these tags
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tags:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - v[.0-9]+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If you specify both only and except, then except will be ignored. .jervis.yml needs to be present on all branches you want to be built. .jervis.yml will be interpreted in the context of that branch so if you specify an allow list in your main branch, then it will not propagate to other branches.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Using regular expressions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You can use regular expressions to allow or block branches:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - /^[.0-9]+-hotfix$/
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Any name surrounded with / in the list of branches is treated as a regular expression. The expression will use Pattern.compile to compile the regex string into a Groovy regular expression.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • yamlFileName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The filename which will be read from GitHub to determine if a Jenkins branch, tag, or pull request should be built. Provide a comma separated list of paths to YAML files in a repository and it will check each path as a fallback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For example, set the value to: .jervis.yml, .ci/jervis.yml and this plugin will first check for valid YAML in .jervis.yml. If no YAML exists, then it will fall back to checking .ci/jervis.yml.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • localBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • logComment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • logSuccess : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Sometimes the user doesn't want to log the builds that succeeded. The trait only enable logging of failed/aborted builds by default. Select this option to include logging of successful builds as well.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • sudoUser : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enter a sudo username of the user you want to comment as on GitLab Server. Remember the token specified should have api and sudo access both (which can only be created by your GitLab Server Admin). It is recommended to create a dummy user in your GitLab Server with an appropriate username like `jenkinsadmin` etc. Leave empty if you want use the owner of the project as the commenter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'MercurialBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'FishEye'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository, such as: http://www.example.org/browse/hg/
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'GoogleCode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'HgWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'Kallithea'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'KilnHG'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'RhodeCode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'RhodeCodeLegacy'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'ScmManager'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as http://YOURSCMMANAGER/scm/repo/NAMESPACE/NAME/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'MercurialInstallationSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • installation : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • multiBranchProjectDisplayNaming
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Some branch source plugins provide additional information about discovered branches like a title or subject of merge or change requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          With this trait, that additional information can be used for the job display names.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Note: Job display name changes do not trigger builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • displayNamingStrategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The different strategies:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Job display name with fallback to name:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Uses the branch source plugin's display name for the PR instead of the raw name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Value for configuration-as-code: OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Name and, if available, display name:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Joins the raw name and the branch source plugin's display name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Value for configuration-as-code: RAW_AND_OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Values: OBJECT_DISPLAY_NAME, RAW_AND_OBJECT_DISPLAY_NAME
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubNotificationContextTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Defines custom context labels to be sent as part of GitHub Status notifications for this project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • contextLabel : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The text of the context label(s) for GitHub status notifications. If using multiple statuses, entries are separated by the specified delimiter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • typeSuffix : boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Appends the relevant suffix to the context label(s) based on the build type. '/pr-merge', '/pr-head' or '/branch'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • multipleStatusDelimiter : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The separator/delimiter used for splitting the Label field into multiple values.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • multipleStatuses : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Configure multiple status notifications to be sent to GitHub.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitLabOriginDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers merge requests where the origin project is the same as the target project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'PathBasedPullRequestFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • inclusionField : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If any of the changed files in a discovered PR match this regex then it will generate a build (unless excluded by the exclusion regex).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • exclusionField : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Any changed files in a discovered pull request that matches this regex will not be considered for the inclusion regex.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'PreBuildMergeTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              These options allow you to perform a merge to a particular branch before building. For example, you could specify an integration branch to be built, and to merge to master. In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful. It then may push the merge back to the remote repository if the Git Push post-build action is selected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • mergeTarget : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The name of the branch within the named repository to merge to, such as master.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • fastForwardMode (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Merge fast-forward mode selection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The default, --ff, gracefully falls back to a merge commit when required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For more information, see the Git Merge Documentation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Values: FF, FF_ONLY, NO_FF
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • mergeRemote : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Name of the repository, such as origin, that contains the branch you specify below. If left blank, it'll default to the name of the first repository configured above.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • mergeStrategy (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Merge strategy selection. This feature is not fully implemented in JGIT.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Values: DEFAULT, RESOLVE, RECURSIVE, OCTOPUS, OURS, SUBTREE, RECURSIVE_THEIRS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'PretestedIntegrationSCMTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitIntegrationStrategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • accumulated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Accumulated Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This strategy merges your commits with the --no-ff switch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • ffonly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Fast Forward only (--ff-only) Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This strategy fast-forward only using the --ff-only switch - or fails
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • squash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Squashed Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This strategy squashes all your commit on a given branch with the --squash option
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • integrationBranch : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                What to specify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The branch name must match your integration branch name. No trailing slash.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Merge is performed the following way

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Squash commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git merge --squash <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git commit -C <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Accumulated commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git merge -m <commitMsg> <Branch matched by git> --no-ff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                When changes are pushed to the integration branch?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Changes are only ever pushed when the build results is SUCCESS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git push <Repository name> <Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                What to specify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The repository name. In git the repository is always the name of the remote. So if you have specified a repository name in your Git configuration. You need to specify the exact same name here, otherwise no integration will be performed. We do the merge based on this.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                No trailing slash on repository name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Remember to specify this when working with NAMED repositories in Git

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • pruneStaleBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • pruneStaleTag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketPublicRepoPullRequestFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If the repository being scanned is a public repository, this behaviour will exclude all pull requests. (Note: This behaviour is not especially useful if scanning a single repository as you could just not include the pull request discovery behaviours in the first place)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'PullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • excludeBranchesWithPRs : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Exclude branches for which there is an open pull request
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'PullRequestLabelsBlackListFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Filter github pull requests out by labels matching any labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'PullRequestLabelsMatchAllFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Filter github pull requests by labels matching all labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'PullRequestLabelsMatchAnyFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Filter github pull requests by labels matching any labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'PullRequestNameFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Filter Bitbucket Pull Requests by matching in title any phrase specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'PullRequestSourceBranchFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Filter Bitbucket Pull Requests by source branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'PullRequestTargetBranchFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Filter Bitbucket Pull Requests by target branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • refSpecs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • templates
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • value : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A ref spec to fetch. Any occurrences of @{remote} will be replaced by the remote name (which defaults to origin) before use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • headRegexFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • tagRegex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • giteaReleaseDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers releases on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • includePreReleases : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If enabled, releases that are marked as pre-release are also discovered
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • artifactToAssetMappingEnabled : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If enabled, artifacts that where archived (i.e. via archiveArtifacts) will be added as assets in the release, but only if the build was successfull.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • remoteName
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • remoteName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'ScmManagerBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the paths that you'd like to sparse checkout. This may be used for saving space (Think about a reference repository). Be sure to use a recent version of Git, at least above 1.7.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • path : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • submoduleOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • disableSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        By disabling support for submodules you can still keep using basic git plugin functionality and just have Jenkins to ignore submodules completely as if they didn't exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • parentCredentials : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use credentials from the default remote of the parent project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • recursiveSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Retrieve all submodules recursively (uses '--recursive' option which requires git>=1.6.5)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • reference : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        To prepare a reference folder with multiple subprojects, create a bare git repository and add all the remote urls then perform a fetch:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          git init --bare
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          git remote add SubProject1 https://gitrepo.com/subproject1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          git remote add SubProject2 https://gitrepo.com/subproject2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          git fetch --all
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • shallow : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • threads : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the number of threads that will be used to update submodules.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If unspecified, the command line git default thread count is used.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • timeout : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify a timeout (in minutes) for submodules operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • trackingSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Retrieve the tip of the configured branch in .gitmodules (Uses '--remote' option which requires git>=1.8.2)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • mrTriggerComment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • commentBody : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Add comment body you want to use to instruct Jenkins CI to rebuild the MR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • onlyTrustedMembersCanTrigger : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • tuleapBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • tuleapNotifyPullRequest
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • tuleapForkPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • tuleapPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • userIdentity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • name : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If given, "GIT_COMMITTER_NAME=[this]" and "GIT_AUTHOR_NAME=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • email : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If given, "GIT_COMMITTER_EMAIL=[this]" and "GIT_AUTHOR_EMAIL=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketWebhookConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Sets the value for committersToIgnore in the Bitbucket Webhook. Value should be a comma separated string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            committerToIgnore is used to prevent triggering Jenkins builds when commits by certain users are made.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • committersToIgnore : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • WebhookListenerBuildConditionsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • alwaysBuildMROpen : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • alwaysBuildMRReOpen : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • alwaysIgnoreMRApproval : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • alwaysIgnoreMRApproved : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • alwaysIgnoreMRUnApproval : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • alwaysIgnoreMRUnApproved : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • alwaysIgnoreMRWorkInProgress : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • alwaysIgnoreNonCodeRelatedUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GitLab will send a webhook to Jenkins when there are updates to the MR including title changes, labels removed/added, etc. Enabling this option will prevent a build running if the cause was one of these updates. Note: these settings do not have any impact on build from comment settings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • headWildcardFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • tagIncludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • tagExcludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'WipeWorkspaceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers branches that have PR's associated with them. This may make sense if you have a notification sent to the team at the end of a triggered build or limited Jenkins resources.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Forks in the same account
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Bitbucket allows for a repository to be forked into a "sibling" repository in the same account but using a different name. This strategy will trust any pull requests from forks that are in the same account as the target repository on the basis that users have to have been granted write permission to account in order create such a fork.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on Bitbucket Cloud.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default the discovered branches / pull requests will all use the same credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Credentials used to check out sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      It must be a SSH key based credential.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Manual webhook configuration requires the user to configure Bitbucket with the Jenkins URL in order to ensure that Bitbucket will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Bitbucket can connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The Manage Jenkins » Configure Jenkins › Bitbucket Endpoints allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • mode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        There are two available modes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Disable hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure Jenkins › Bitbucket Endpoints
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'com.cloudogu.scmmanager.scm.BranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'com.cloudogu.scmmanager.scm.TagDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • dagshubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.ForkPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.OriginPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • dagshubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitLabBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Only branches that are not also filed as MRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If you are discovering origin merge requests, it may not make sense to discover the same changes both as a merge request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Only branches that are also filed as MRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a merge request against this text.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Ignores whether the branch is also filed as a merge request and instead discovers all branches on the origin project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • branchesAlwaysIncludedRegex : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Regular expression of branches that should always be included regardless of whether a merge request exists or not for those branches.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitLabSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              By default the discovered branches / merge requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitLabTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • headRegexFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • headWildcardFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Space-separated list of name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Space-separated list of name patterns to ignore even if matched by the includes list. For example: release alpha-* beta-*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • headRegexFilterWithPR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • tagRegex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • headWildcardFilterWithPR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • tagIncludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • tagExcludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • giteaBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a pull request against this text.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Only branches that are also filed as PRs or main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover branches that are also files as PRs (have open PRs) or that are the master / main branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • giteaForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Contributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of contributors to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on a Gitea instance that allows signup.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitLabTrustMembers
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitLabTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitLabTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitLabTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • giteaTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • giteaTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • giteaTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • giteaPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • giteaSSHCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • giteaTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • giteaWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Manual webhook configuration requires the user to configure Gitea with the Jenkins URL in order to ensure that Gitea will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Gitea can connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The Manage Jenkins » Configure System › Gitea Server allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • mode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    There are two available modes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Disable hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure System › Gitea Server
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are discovering origin pull requests, you may not want to also build the source branches for those pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Similar to discovering origin pull requests, but discovers the branch rather than the pull request. This means env.GIT_BRANCH will be set to the branch name rather than PR-#. Also, status notifications for these builds will only be applied to the commit and not to the pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Collaborators
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of collaborators to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody. NOTE: all collaborators are trusted, even if they are only members of a team with read permission.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on GitHub.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    From users with Admin or Write permission
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pull requests forks will be treated as trusted if and only if the fork owner has either Admin or Write permissions on the origin repository. This is the recommended policy. Note that this strategy requires the Review a user's permission level API, as a result on GitHub Enterprise Server versions before 2.12 this is the same as trusting Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • git
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'GiteaSCMSource'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • globalLib
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • credential : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • path : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A Perforce Depot path to the library.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For example: //depot/myLibrary/...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • charset : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • excludes : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • filter (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • latest
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • latestChange : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • latestWithPin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • latestWithPin : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Polling latest change with pin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When enabled, in case of a pinned checkout, polling ignores the pin or the label specified in the checkout step and polls till the latest change.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • pathFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • path : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Depot path filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Changes can be filtered to not trigger a build; if all the files within a change match the specified path, the build is filtered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For example, with a Filter of " //depot/main/tests ":

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Case A (change will be filtered):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/tests/index.xml
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/tests/001/test.xml
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/tests/002/test.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Case B (change will not be filtered, as build.xml is outside of the filter):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/src/build.xml
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/tests/004/test.xml
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/tests/005/test.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This is not Perforce syntax. Use of ... and * patterns are not supported. Only paths to directories are supported.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • viewPattern
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • patternText : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Java Pattern filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Changes can be filtered to not trigger a build; if none of the files within a change match a Java pattern (regular expression) listed, the build is filtered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For example, with the following regular expressions:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              //depot/main/tests.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              //depot/main/src/.*\.cpp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              //depot/main/build/.*(?:\.rb|\.py|\.bat|Jenkinsfile)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              //depot/main/lib/(?!Lib1|Lib2).*

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Case A (change will not be filtered, as these files match our first pattern on "tests"):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/tests/CONTRIUBTING.md
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/tests/001/index.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Case B (Be careful with incomplete file paths! Change will NOT be filtered,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              as this file matches a pattern which was likely intended as describing a "tests/" directory.)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/tests.doc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Case C (change will NOT be filtered, as all files match our fourth pattern looking for script files in 'build/'):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/build/rbs/deploy_server.rb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/build/deploy/deploy.bat
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/build/Jenkinsfile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Case D (change will be filtered, as no file matches our second pattern for ".cpp" files under "main/src"):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/src/howto.doc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/src/oldmain.c
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/src/art/splash.bmp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/src/bt/funnelcake.php

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Case E (change will be filtered. Lib1 is included in a negative lookahead, and thus is excluded.)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/lib/Lib1/build.xml
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • caseSensitive : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • incremental
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • perChange : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Polling per change

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When enabled, only the one, oldest changelist returned by polling is built.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              If P4_INCREMENTAL environment variable (or build parameter) is set to "false", polling per change is ignored and all changelists are built.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • userFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • user : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              User name filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Changes can be filtered to not trigger a build; if the owner of a change matches the specified name, the build is filtered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • viewFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • viewMask : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              View Mask filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Changes can be filtered to not trigger a build; if none of the files within a change are contained in the view mask, the build is filtered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For example, with a View Mask Filter of:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              //depot/main/tests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              -//depot/main/tests/001

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Case A (change will not be filtered, as index.xml is in the view mask):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/tests/index.xml
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/tests/001/test.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Case B (change will not be filtered, as index.xml is in the view mask):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/test/index.xml
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/src/build.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Case C (change will be filtered, as no file is in the view mask):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/src/build.xml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Case D (change will be filtered, as no file is in the view mask):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Files:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/src/build.xml
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • //depot/main/tests/001/test.xml
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • format : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • id : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • includes : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • populate (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • autoClean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • replace : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              REPLACE missing/modified files

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Perforce will check out and overwrite any depot files which are either missing from workspace, or have been modified locally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • delete : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              DELETE generated files

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Perforce will delete any local files that are not in the depot.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • tidy : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • modtime : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • quiet : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Suppressing info messages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enables the -q flag for all applicable Perforce operations. Summary details will still be displayed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • pin : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Pinning a build at Perforce Label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When a build is triggered by Polling, Build Now or an external Action, the workspace will sync only to the specified label. Any other specified change or label will be ignored.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Supports variable expansion e.g. ${VAR}. If 'now' is used, or a variable that expands to 'now', then the latest change is used (within the scope of the workspace view).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • parallel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • enable : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • path : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • threads : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • minfiles : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • minbytes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • previewOnly
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • quiet : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Suppressing info messages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enables the -q flag for all applicable Perforce operations. Summary details will still be displayed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • pin : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • flushOnly
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • quiet : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • pin : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Pinning a build at Perforce Label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When a build is triggered by Polling, Build Now or an external Action, the workspace will flush only to the specified label or changelist number. Any other specified change or label will be ignored.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Supports variable expansion e.g. ${VAR}. If 'now' is used, or a variable that expands to 'now', then the latest change is used (within the scope of the workspace view).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • forceClean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • have : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • quiet : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Suppressing info messages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enables the -q flag for all applicable Perforce operations. Summary details will still be displayed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • pin : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Pinning a build at Perforce Label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When a build is triggered by Polling, Build Now or an external Action, the workspace will sync only to the specified label. Any other specified change or label will be ignored.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Supports variable expansion e.g. ${VAR}. If 'now' is used, or a variable that expands to 'now', then the latest change is used (within the scope of the workspace view).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • parallel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • enable : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • path : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • threads : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • minfiles : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • minbytes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • graphClean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • quiet : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Suppressing info messages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enables the -q flag for all applicable Perforce operations. Summary details will still be displayed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • pin : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Pinning a build at Perforce Label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When a build is triggered by Polling, Build Now or an external Action, the workspace will sync only to the specified label. Any other specified change or label will be ignored.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Supports variable expansion e.g. ${VAR}. If 'now' is used, or a variable that expands to 'now', then the latest change is used (within the scope of the workspace view).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • parallel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • enable : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • path : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • threads : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • minfiles : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • minbytes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • syncOnly
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • revert : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • have : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • force : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • modtime : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • quiet : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Suppressing info messages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enables the -q flag for all applicable Perforce operations. Summary details will still be displayed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • pin : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Pinning a build at Perforce Label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When a build is triggered by Polling, Build Now or an external Action, the workspace will sync only to the specified label. Any other specified change or label will be ignored.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Supports variable expansion e.g. ${VAR}. If 'now' is used, or a variable that expands to 'now', then the latest change is used (within the scope of the workspace view).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • parallel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • enable : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • path : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • threads : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • minfiles : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • minbytes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • traits (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'ApprovedPullRequestTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              No approval necessary.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              No check of approvals will be performed before building.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Any approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Before building the pull request must be approved. This may be performed by the author or someone else.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Non-author approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Before building the pull request must be approved and that approval cannot be performed by the author of the pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Author and Non-author approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Before building the pull request must be approved by the author and a non-author.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • authorInChangelog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'BitbucketBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers branches in the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketBuildStatusNotifications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Configure the Bitbucket notifications.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • disableNotificationForNotBuildJobs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • sendSuccessNotificationForUnstableBuild : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'BitbucketGitBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • assembla
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • cgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • fisheye
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitblit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitLab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • kiln
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • phabricator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repo : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • redmine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • jbSpace
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Provide the absolute URL to your repository in JetBrains SpaceCode in the following format: https://<your SpaceCode instance>/p/<project key>/repositories/<repository name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • viewgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'BitbucketJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'BitbucketPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers open pull requests in the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • buildStatusNameCustomPart
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Customize the pipeline status name used by Jenkins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • buildStatusNameCustomPart : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enter a string to customize the status/context name for status updates published to GitLab. For a branch build the default name would be 'jenkinsci/branch'. With the buildStatusNameCustomPart 'custom' the name would be 'jenkinsci/custom/branch'. This allows to have multiple GitLab-Branch-Sources for the same GitLab-project configured.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • buildStatusNameOverwrite : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Overwrites the build status name including the jenkinsci default part.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Instead of 'jenkinsci/custom/branch' just 'custom/branch'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • ignoreTypeInStatusName : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'ChangeDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • queryString : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Provide an additional query string to search for open changes. The status:open is implicitly added and does not need to be specified. See Gerrit search operators documentation for a detailed list of the supported search operators.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Examples:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • -is:wip
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            does not include work-in-progress changes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • is:private
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            includes private changes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • checkoutOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify a timeout (in minutes) for checkout.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • cleanAfterCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Clean up the workspace after every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • cleanBeforeCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Clean up the workspace before every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'CleanMercurialSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        When this behaviour is present, each build will wipe any local modifications or untracked files in the repository checkout. This is often a convenient way to ensure that a build is not using any artifacts from earlier builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • cloneOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • shallow : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • noTags : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Deselect this to perform a clone without tags, saving time and disk space when you just want to access what is specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • reference : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify a timeout (in minutes) for clone and fetch operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • honorRefspec : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Perform initial clone using the refspec defined for the repository. This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'DisableStatusUpdateTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Disables notifications (commit status updates) to GitHub for builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • discoverOtherRefs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discovers other specified refs on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • ref : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The pattern under /refs on the remote repository to discover, can contain a wildcard.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Example: test/*/merged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • nameMapping : String (optional)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Mapping for how the ref can be named in for example the @Library.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Example: test-@{1}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Where @{1} replaces the first wildcard in the ref when discovered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              By default it will be "namespace_before_wildcard-@{1}". E.g. if ref is "test/*/merged" the default mapping would be "test-@{1}".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'FilterChecksTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • queryOperator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Values: ID, SCHEME
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • queryString : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Provide a query string to search for pending checks. Depending on which mode was chosen, this either should be a checker-scheme or the UUID of a specific checker.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitLabForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discovers merge requests where the origin project is a fork of the target project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              One of the great powers of merge requests is that anyone with read access to a project can fork it, commit some changes to their fork and then create a merge request against the original project with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox merge requests in order to mitigate against malicious merge requests. In order to protect against a malicious merge request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for merge requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Merge requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin project and not from the merge request branch on the fork project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Members
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Merge requests from collaborators to the origin project will be treated as trusted, all other merge requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the project does not have permission to query the list of contributors to the origin project then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Trusted Members
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Merge requests forks will be treated as trusted if and only if the fork owner has either Developer or Maintainer or Owner Access Level in the origin project. This is the recommended policy.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              All merge requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public project hosted on a GitLab instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Type: jenkins.scm.api.trait.SCMHeadAuthority<? super io.jenkins.plugins.gitlabbranchsource.GitLabSCMSourceRequest, ? extends jenkins.scm.api.mixin.ChangeRequestSCMHead2, ? extends jenkins.scm.api.SCMRevision>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • buildMRForksNotMirror : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Add discovery of merge requests where the origin project is a fork of a certain project, but the target project is not the original forked project. To be used in case one has a GitLab project which is a fork of another project from another team, in order to isolate artefacts and allow an MR flow. This means using MRs inside that fork from branches in the fork back to the fork's default branch. (Implements https://github.com/jenkinsci/gitlab-branch-source-plugin/issues/167)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • assembla
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • cgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • fisheye
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitblit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitLab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • kiln
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • phabricator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repo : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • redmine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • jbSpace
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Provide the absolute URL to your repository in JetBrains SpaceCode in the following format: https://<your SpaceCode instance>/p/<project key>/repositories/<repository name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • viewgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'GitHubJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubSourceChecks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • verboseConsoleLog : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If this option is checked, verbose log will be output to build console; the verbose log is useful for debugging the publisher creation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubStatusChecks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • name : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • skip : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • skipNotifications : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If this option is checked, the notifications sent by the GitHub Branch Source Plugin will be disabled.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • skipProgressUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • suppressLogs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • unstableBuildNeutral : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • lfs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitlabAvatar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • disableProjectAvatar : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Due to a GitLab bug, sometimes it is not possible to GitLab API to fetch GitLab Avatar for private projects or when the api doesn't have token access. You may choose to skip avatar for projects if you want to avoid broken or self generated avatars.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitlabMarkUnstableAsSuccess
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • markUnstableAsSuccess : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitlabSkipNotifications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitTool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitTool : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitLabHookRegistration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • webHookMode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • systemHookMode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubIgnoreDraftPullRequestFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ignoreOnPush
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • jervisFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This will look at the root of a GitHub reference for .jervis.yml for the branches and tags filtering. You can customize the name of the YAML file searched for if you like.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For Tags:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • It will filter for the tag name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For Branches:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • It will filter for the branch name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • It will filter for pull requests destined for the branch name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Example YAML

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          More on specify branches and tags to build

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          By default Jervis will generate Jenkins jobs for all branches that have a .jervis.yml file. You can control and limit this behavior by specifying the branches or tags key in your .jervis.yml.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Allow or block branches and tags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          You can either create an allow list of branches (only) or a block list of branches (except) to be built.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          # block branches from building
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            except:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - legacy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - experimental
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          # allow only these branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - stable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The same YAML can be applied to tags.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          # block tags from building
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tags:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            except:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - .*-rc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - .*-beta
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          # allow only these tags
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tags:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - v[.0-9]+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If you specify both only and except, then except will be ignored. .jervis.yml needs to be present on all branches you want to be built. .jervis.yml will be interpreted in the context of that branch so if you specify an allow list in your main branch, then it will not propagate to other branches.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Using regular expressions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          You can use regular expressions to allow or block branches:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - /^[.0-9]+-hotfix$/
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Any name surrounded with / in the list of branches is treated as a regular expression. The expression will use Pattern.compile to compile the regex string into a Groovy regular expression.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • yamlFileName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The filename which will be read from GitHub to determine if a Jenkins branch, tag, or pull request should be built. Provide a comma separated list of paths to YAML files in a repository and it will check each path as a fallback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            For example, set the value to: .jervis.yml, .ci/jervis.yml and this plugin will first check for valid YAML in .jervis.yml. If no YAML exists, then it will fall back to checking .ci/jervis.yml.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • localBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • logComment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • logSuccess : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Sometimes the user doesn't want to log the builds that succeeded. The trait only enable logging of failed/aborted builds by default. Select this option to include logging of successful builds as well.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • sudoUser : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enter a sudo username of the user you want to comment as on GitLab Server. Remember the token specified should have api and sudo access both (which can only be created by your GitLab Server Admin). It is recommended to create a dummy user in your GitLab Server with an appropriate username like `jenkinsadmin` etc. Leave empty if you want use the owner of the project as the commenter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'MercurialBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'FishEye'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository, such as: http://www.example.org/browse/hg/
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'GoogleCode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'HgWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'Kallithea'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'KilnHG'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'RhodeCode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'RhodeCodeLegacy'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'ScmManager'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as http://YOURSCMMANAGER/scm/repo/NAMESPACE/NAME/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'MercurialInstallationSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • installation : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • multiBranchProjectDisplayNaming
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some branch source plugins provide additional information about discovered branches like a title or subject of merge or change requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            With this trait, that additional information can be used for the job display names.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Note: Job display name changes do not trigger builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • displayNamingStrategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The different strategies:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Job display name with fallback to name:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Uses the branch source plugin's display name for the PR instead of the raw name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Value for configuration-as-code: OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Name and, if available, display name:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Joins the raw name and the branch source plugin's display name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Value for configuration-as-code: RAW_AND_OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Values: OBJECT_DISPLAY_NAME, RAW_AND_OBJECT_DISPLAY_NAME
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubNotificationContextTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Defines custom context labels to be sent as part of GitHub Status notifications for this project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • contextLabel : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The text of the context label(s) for GitHub status notifications. If using multiple statuses, entries are separated by the specified delimiter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • typeSuffix : boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Appends the relevant suffix to the context label(s) based on the build type. '/pr-merge', '/pr-head' or '/branch'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • multipleStatusDelimiter : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The separator/delimiter used for splitting the Label field into multiple values.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • multipleStatuses : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Configure multiple status notifications to be sent to GitHub.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitLabOriginDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discovers merge requests where the origin project is the same as the target project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'PathBasedPullRequestFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • inclusionField : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              If any of the changed files in a discovered PR match this regex then it will generate a build (unless excluded by the exclusion regex).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • exclusionField : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Any changed files in a discovered pull request that matches this regex will not be considered for the inclusion regex.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'PreBuildMergeTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                These options allow you to perform a merge to a particular branch before building. For example, you could specify an integration branch to be built, and to merge to master. In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful. It then may push the merge back to the remote repository if the Git Push post-build action is selected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • mergeTarget : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The name of the branch within the named repository to merge to, such as master.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • fastForwardMode (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merge fast-forward mode selection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The default, --ff, gracefully falls back to a merge commit when required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For more information, see the Git Merge Documentation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Values: FF, FF_ONLY, NO_FF
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • mergeRemote : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Name of the repository, such as origin, that contains the branch you specify below. If left blank, it'll default to the name of the first repository configured above.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • mergeStrategy (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merge strategy selection. This feature is not fully implemented in JGIT.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Values: DEFAULT, RESOLVE, RECURSIVE, OCTOPUS, OURS, SUBTREE, RECURSIVE_THEIRS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'PretestedIntegrationSCMTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitIntegrationStrategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • accumulated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Accumulated Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This strategy merges your commits with the --no-ff switch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • ffonly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Fast Forward only (--ff-only) Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This strategy fast-forward only using the --ff-only switch - or fails
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • squash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Squashed Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This strategy squashes all your commit on a given branch with the --squash option
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • integrationBranch : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  What to specify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The branch name must match your integration branch name. No trailing slash.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merge is performed the following way

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Squash commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              git merge --squash <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              git commit -C <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Accumulated commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              git merge -m <commitMsg> <Branch matched by git> --no-ff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  When changes are pushed to the integration branch?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Changes are only ever pushed when the build results is SUCCESS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              git push <Repository name> <Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  What to specify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The repository name. In git the repository is always the name of the remote. So if you have specified a repository name in your Git configuration. You need to specify the exact same name here, otherwise no integration will be performed. We do the merge based on this.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  No trailing slash on repository name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Remember to specify this when working with NAMED repositories in Git

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • pruneStaleBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • pruneStaleTag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketPublicRepoPullRequestFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If the repository being scanned is a public repository, this behaviour will exclude all pull requests. (Note: This behaviour is not especially useful if scanning a single repository as you could just not include the pull request discovery behaviours in the first place)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'PullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • excludeBranchesWithPRs : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Exclude branches for which there is an open pull request
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'PullRequestLabelsBlackListFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Filter github pull requests out by labels matching any labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'PullRequestLabelsMatchAllFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Filter github pull requests by labels matching all labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'PullRequestLabelsMatchAnyFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Filter github pull requests by labels matching any labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'PullRequestNameFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Filter Bitbucket Pull Requests by matching in title any phrase specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'PullRequestSourceBranchFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Filter Bitbucket Pull Requests by source branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'PullRequestTargetBranchFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Filter Bitbucket Pull Requests by target branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • refSpecs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • templates
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • value : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A ref spec to fetch. Any occurrences of @{remote} will be replaced by the remote name (which defaults to origin) before use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • headRegexFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • tagRegex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • giteaReleaseDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers releases on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • includePreReleases : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If enabled, releases that are marked as pre-release are also discovered
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • artifactToAssetMappingEnabled : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If enabled, artifacts that where archived (i.e. via archiveArtifacts) will be added as assets in the release, but only if the build was successfull.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • remoteName
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • remoteName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'ScmManagerBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nested Object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the paths that you'd like to sparse checkout. This may be used for saving space (Think about a reference repository). Be sure to use a recent version of Git, at least above 1.7.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • path : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • submoduleOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • disableSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          By disabling support for submodules you can still keep using basic git plugin functionality and just have Jenkins to ignore submodules completely as if they didn't exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • parentCredentials : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Use credentials from the default remote of the parent project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • recursiveSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Retrieve all submodules recursively (uses '--recursive' option which requires git>=1.6.5)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • reference : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          To prepare a reference folder with multiple subprojects, create a bare git repository and add all the remote urls then perform a fetch:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git init --bare
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git remote add SubProject1 https://gitrepo.com/subproject1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git remote add SubProject2 https://gitrepo.com/subproject2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git fetch --all
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • shallow : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • threads : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the number of threads that will be used to update submodules.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If unspecified, the command line git default thread count is used.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • timeout : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify a timeout (in minutes) for submodules operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • trackingSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Retrieve the tip of the configured branch in .gitmodules (Uses '--remote' option which requires git>=1.8.2)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • mrTriggerComment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • commentBody : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Add comment body you want to use to instruct Jenkins CI to rebuild the MR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • onlyTrustedMembersCanTrigger : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • tuleapBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • tuleapNotifyPullRequest
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • tuleapForkPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • tuleapPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • userIdentity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • name : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If given, "GIT_COMMITTER_NAME=[this]" and "GIT_AUTHOR_NAME=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • email : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If given, "GIT_COMMITTER_EMAIL=[this]" and "GIT_AUTHOR_EMAIL=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketWebhookConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Sets the value for committersToIgnore in the Bitbucket Webhook. Value should be a comma separated string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              committerToIgnore is used to prevent triggering Jenkins builds when commits by certain users are made.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • committersToIgnore : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • WebhookListenerBuildConditionsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • alwaysBuildMROpen : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • alwaysBuildMRReOpen : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • alwaysIgnoreMRApproval : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • alwaysIgnoreMRApproved : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • alwaysIgnoreMRUnApproval : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • alwaysIgnoreMRUnApproved : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • alwaysIgnoreMRWorkInProgress : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • alwaysIgnoreNonCodeRelatedUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GitLab will send a webhook to Jenkins when there are updates to the MR including title changes, labels removed/added, etc. Enabling this option will prevent a build running if the cause was one of these updates. Note: these settings do not have any impact on build from comment settings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • headWildcardFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • tagIncludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • tagExcludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'WipeWorkspaceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers branches that have PR's associated with them. This may make sense if you have a notification sent to the team at the end of a triggered build or limited Jenkins resources.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Forks in the same account
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Bitbucket allows for a repository to be forked into a "sibling" repository in the same account but using a different name. This strategy will trust any pull requests from forks that are in the same account as the target repository on the basis that users have to have been granted write permission to account in order create such a fork.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on Bitbucket Cloud.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      By default the discovered branches / pull requests will all use the same credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Credentials used to check out sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        It must be a SSH key based credential.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Manual webhook configuration requires the user to configure Bitbucket with the Jenkins URL in order to ensure that Bitbucket will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Bitbucket can connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The Manage Jenkins » Configure Jenkins › Bitbucket Endpoints allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • mode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          There are two available modes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Disable hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure Jenkins › Bitbucket Endpoints
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'com.cloudogu.scmmanager.scm.BranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'com.cloudogu.scmmanager.scm.TagDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • dagshubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.ForkPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.OriginPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • dagshubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitLabBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Only branches that are not also filed as MRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If you are discovering origin merge requests, it may not make sense to discover the same changes both as a merge request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Only branches that are also filed as MRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a merge request against this text.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Ignores whether the branch is also filed as a merge request and instead discovers all branches on the origin project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • branchesAlwaysIncludedRegex : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Regular expression of branches that should always be included regardless of whether a merge request exists or not for those branches.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitLabSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                By default the discovered branches / merge requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitLabTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • headRegexFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • headWildcardFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Space-separated list of name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Space-separated list of name patterns to ignore even if matched by the includes list. For example: release alpha-* beta-*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • headRegexFilterWithPR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • tagRegex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • headWildcardFilterWithPR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • tagIncludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • tagExcludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • giteaBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a pull request against this text.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Only branches that are also filed as PRs or main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover branches that are also files as PRs (have open PRs) or that are the master / main branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • giteaForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Contributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of contributors to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on a Gitea instance that allows signup.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitLabTrustMembers
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitLabTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitLabTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitLabTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • giteaTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • giteaTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • giteaTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • giteaPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • giteaSSHCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • giteaTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • giteaWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Manual webhook configuration requires the user to configure Gitea with the Jenkins URL in order to ensure that Gitea will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Gitea can connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Manage Jenkins » Configure System › Gitea Server allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • mode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      There are two available modes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Disable hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure System › Gitea Server
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If you are discovering origin pull requests, you may not want to also build the source branches for those pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Similar to discovering origin pull requests, but discovers the branch rather than the pull request. This means env.GIT_BRANCH will be set to the branch name rather than PR-#. Also, status notifications for these builds will only be applied to the commit and not to the pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Collaborators
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of collaborators to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody. NOTE: all collaborators are trusted, even if they are only members of a team with read permission.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on GitHub.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      From users with Admin or Write permission
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Pull requests forks will be treated as trusted if and only if the fork owner has either Admin or Write permissions on the origin repository. This is the recommended policy. Note that this strategy requires the Review a user's permission level API, as a result on GitHub Enterprise Server versions before 2.12 this is the same as trusting Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • multiGraph
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'MercurialSCMSource'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • scmManager
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • scmManagerSvn
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • fromScm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • jetbrains-space-code
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • spaceConnectionId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • projectKey : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repository : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • branchSpec : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Reference branches in the format "+|-:". Use + to include and - to exclude branches. Use * as a wildcard. Use ; to separate branches.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • id : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • mergeRequestSourceBranchSpec : String (optional)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Merge request source branch must match the specified branches.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Reference branches in the format "+|-:". Use + to include and - to exclude branches. Use * as a wildcard. Use ; to separate branches.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • mergeRequestTargetBranchSpec : String (optional)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Merge request target branch must match the specified branches.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Reference branches in the format "+|-:". Use + to include and - to exclude branches. Use * as a wildcard. Use ; to separate branches.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • mergeRequestTitleRegex : String (optional)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Merge request title must match the specified regular expression.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Regular expression must match the entire merge request title, not just a part of it. For example, to exclude all merge requests with a title starting with "WIP" from triggering builds, specify (?!WIP).+ as a regex.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • spaceWebhookId : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • traits (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'ApprovedPullRequestTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                No approval necessary.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                No check of approvals will be performed before building.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Any approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Before building the pull request must be approved. This may be performed by the author or someone else.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Non-author approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Before building the pull request must be approved and that approval cannot be performed by the author of the pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Author and Non-author approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Before building the pull request must be approved by the author and a non-author.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • authorInChangelog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'BitbucketBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers branches in the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketBuildStatusNotifications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Configure the Bitbucket notifications.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • disableNotificationForNotBuildJobs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • sendSuccessNotificationForUnstableBuild : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'BitbucketGitBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • assembla
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • cgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • fisheye
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitblit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitLab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • kiln
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • phabricator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repo : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • redmine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • jbSpace
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Provide the absolute URL to your repository in JetBrains SpaceCode in the following format: https://<your SpaceCode instance>/p/<project key>/repositories/<repository name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • viewgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'BitbucketJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'BitbucketPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers open pull requests in the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • buildStatusNameCustomPart
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Customize the pipeline status name used by Jenkins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • buildStatusNameCustomPart : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enter a string to customize the status/context name for status updates published to GitLab. For a branch build the default name would be 'jenkinsci/branch'. With the buildStatusNameCustomPart 'custom' the name would be 'jenkinsci/custom/branch'. This allows to have multiple GitLab-Branch-Sources for the same GitLab-project configured.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • buildStatusNameOverwrite : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Overwrites the build status name including the jenkinsci default part.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Instead of 'jenkinsci/custom/branch' just 'custom/branch'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • ignoreTypeInStatusName : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'ChangeDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • queryString : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Provide an additional query string to search for open changes. The status:open is implicitly added and does not need to be specified. See Gerrit search operators documentation for a detailed list of the supported search operators.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Examples:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • -is:wip
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              does not include work-in-progress changes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • is:private
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              includes private changes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • checkoutOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify a timeout (in minutes) for checkout.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • cleanAfterCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Clean up the workspace after every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • cleanBeforeCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Clean up the workspace before every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'CleanMercurialSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          When this behaviour is present, each build will wipe any local modifications or untracked files in the repository checkout. This is often a convenient way to ensure that a build is not using any artifacts from earlier builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • cloneOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • shallow : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • noTags : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Deselect this to perform a clone without tags, saving time and disk space when you just want to access what is specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • reference : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify a timeout (in minutes) for clone and fetch operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • honorRefspec : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Perform initial clone using the refspec defined for the repository. This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'DisableStatusUpdateTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Disables notifications (commit status updates) to GitHub for builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • discoverOtherRefs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers other specified refs on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • ref : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The pattern under /refs on the remote repository to discover, can contain a wildcard.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Example: test/*/merged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • nameMapping : String (optional)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Mapping for how the ref can be named in for example the @Library.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Example: test-@{1}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Where @{1} replaces the first wildcard in the ref when discovered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                By default it will be "namespace_before_wildcard-@{1}". E.g. if ref is "test/*/merged" the default mapping would be "test-@{1}".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'FilterChecksTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • queryOperator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Values: ID, SCHEME
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • queryString : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Provide a query string to search for pending checks. Depending on which mode was chosen, this either should be a checker-scheme or the UUID of a specific checker.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitLabForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers merge requests where the origin project is a fork of the target project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                One of the great powers of merge requests is that anyone with read access to a project can fork it, commit some changes to their fork and then create a merge request against the original project with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox merge requests in order to mitigate against malicious merge requests. In order to protect against a malicious merge request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for merge requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Merge requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin project and not from the merge request branch on the fork project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Members
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Merge requests from collaborators to the origin project will be treated as trusted, all other merge requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the project does not have permission to query the list of contributors to the origin project then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Trusted Members
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Merge requests forks will be treated as trusted if and only if the fork owner has either Developer or Maintainer or Owner Access Level in the origin project. This is the recommended policy.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                All merge requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public project hosted on a GitLab instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Type: jenkins.scm.api.trait.SCMHeadAuthority<? super io.jenkins.plugins.gitlabbranchsource.GitLabSCMSourceRequest, ? extends jenkins.scm.api.mixin.ChangeRequestSCMHead2, ? extends jenkins.scm.api.SCMRevision>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • buildMRForksNotMirror : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Add discovery of merge requests where the origin project is a fork of a certain project, but the target project is not the original forked project. To be used in case one has a GitLab project which is a fork of another project from another team, in order to isolate artefacts and allow an MR flow. This means using MRs inside that fork from branches in the fork back to the fork's default branch. (Implements https://github.com/jenkinsci/gitlab-branch-source-plugin/issues/167)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • assembla
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • cgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • fisheye
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitblit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitLab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • kiln
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • phabricator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repo : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • redmine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • jbSpace
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Provide the absolute URL to your repository in JetBrains SpaceCode in the following format: https://<your SpaceCode instance>/p/<project key>/repositories/<repository name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • viewgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'GitHubJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubSourceChecks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • verboseConsoleLog : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If this option is checked, verbose log will be output to build console; the verbose log is useful for debugging the publisher creation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubStatusChecks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • name : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • skip : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • skipNotifications : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If this option is checked, the notifications sent by the GitHub Branch Source Plugin will be disabled.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • skipProgressUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • suppressLogs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • unstableBuildNeutral : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • lfs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitlabAvatar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • disableProjectAvatar : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Due to a GitLab bug, sometimes it is not possible to GitLab API to fetch GitLab Avatar for private projects or when the api doesn't have token access. You may choose to skip avatar for projects if you want to avoid broken or self generated avatars.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitlabMarkUnstableAsSuccess
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • markUnstableAsSuccess : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitlabSkipNotifications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitTool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitTool : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitLabHookRegistration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • webHookMode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • systemHookMode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitHubIgnoreDraftPullRequestFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • ignoreOnPush
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • jervisFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This will look at the root of a GitHub reference for .jervis.yml for the branches and tags filtering. You can customize the name of the YAML file searched for if you like.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            For Tags:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • It will filter for the tag name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            For Branches:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • It will filter for the branch name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • It will filter for pull requests destined for the branch name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Example YAML

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            More on specify branches and tags to build

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            By default Jervis will generate Jenkins jobs for all branches that have a .jervis.yml file. You can control and limit this behavior by specifying the branches or tags key in your .jervis.yml.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Allow or block branches and tags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You can either create an allow list of branches (only) or a block list of branches (except) to be built.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            # block branches from building
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              except:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - legacy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - experimental
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            # allow only these branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - stable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The same YAML can be applied to tags.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            # block tags from building
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tags:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              except:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - .*-rc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - .*-beta
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            # allow only these tags
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tags:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - v[.0-9]+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If you specify both only and except, then except will be ignored. .jervis.yml needs to be present on all branches you want to be built. .jervis.yml will be interpreted in the context of that branch so if you specify an allow list in your main branch, then it will not propagate to other branches.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Using regular expressions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You can use regular expressions to allow or block branches:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - /^[.0-9]+-hotfix$/
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Any name surrounded with / in the list of branches is treated as a regular expression. The expression will use Pattern.compile to compile the regex string into a Groovy regular expression.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • yamlFileName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The filename which will be read from GitHub to determine if a Jenkins branch, tag, or pull request should be built. Provide a comma separated list of paths to YAML files in a repository and it will check each path as a fallback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For example, set the value to: .jervis.yml, .ci/jervis.yml and this plugin will first check for valid YAML in .jervis.yml. If no YAML exists, then it will fall back to checking .ci/jervis.yml.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • localBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • logComment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • logSuccess : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Sometimes the user doesn't want to log the builds that succeeded. The trait only enable logging of failed/aborted builds by default. Select this option to include logging of successful builds as well.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • sudoUser : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enter a sudo username of the user you want to comment as on GitLab Server. Remember the token specified should have api and sudo access both (which can only be created by your GitLab Server Admin). It is recommended to create a dummy user in your GitLab Server with an appropriate username like `jenkinsadmin` etc. Leave empty if you want use the owner of the project as the commenter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'MercurialBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'FishEye'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository, such as: http://www.example.org/browse/hg/
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'GoogleCode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'HgWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'Kallithea'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'KilnHG'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'RhodeCode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'RhodeCodeLegacy'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'ScmManager'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the root URL serving this repository (such as http://YOURSCMMANAGER/scm/repo/NAMESPACE/NAME/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'MercurialInstallationSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • installation : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • multiBranchProjectDisplayNaming
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Some branch source plugins provide additional information about discovered branches like a title or subject of merge or change requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              With this trait, that additional information can be used for the job display names.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Note: Job display name changes do not trigger builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • displayNamingStrategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The different strategies:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Job display name with fallback to name:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Uses the branch source plugin's display name for the PR instead of the raw name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Value for configuration-as-code: OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Name and, if available, display name:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Joins the raw name and the branch source plugin's display name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Value for configuration-as-code: RAW_AND_OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Values: OBJECT_DISPLAY_NAME, RAW_AND_OBJECT_DISPLAY_NAME
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubNotificationContextTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Defines custom context labels to be sent as part of GitHub Status notifications for this project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • contextLabel : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The text of the context label(s) for GitHub status notifications. If using multiple statuses, entries are separated by the specified delimiter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • typeSuffix : boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Appends the relevant suffix to the context label(s) based on the build type. '/pr-merge', '/pr-head' or '/branch'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • multipleStatusDelimiter : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The separator/delimiter used for splitting the Label field into multiple values.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • multipleStatuses : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Configure multiple status notifications to be sent to GitHub.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitLabOriginDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers merge requests where the origin project is the same as the target project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'PathBasedPullRequestFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • inclusionField : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If any of the changed files in a discovered PR match this regex then it will generate a build (unless excluded by the exclusion regex).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • exclusionField : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Any changed files in a discovered pull request that matches this regex will not be considered for the inclusion regex.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'PreBuildMergeTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  These options allow you to perform a merge to a particular branch before building. For example, you could specify an integration branch to be built, and to merge to master. In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful. It then may push the merge back to the remote repository if the Git Push post-build action is selected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • mergeTarget : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The name of the branch within the named repository to merge to, such as master.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • fastForwardMode (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merge fast-forward mode selection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The default, --ff, gracefully falls back to a merge commit when required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For more information, see the Git Merge Documentation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Values: FF, FF_ONLY, NO_FF
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • mergeRemote : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Name of the repository, such as origin, that contains the branch you specify below. If left blank, it'll default to the name of the first repository configured above.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • mergeStrategy (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merge strategy selection. This feature is not fully implemented in JGIT.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Values: DEFAULT, RESOLVE, RECURSIVE, OCTOPUS, OURS, SUBTREE, RECURSIVE_THEIRS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'PretestedIntegrationSCMTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitIntegrationStrategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • accumulated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Accumulated Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This strategy merges your commits with the --no-ff switch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ffonly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fast Forward only (--ff-only) Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This strategy fast-forward only using the --ff-only switch - or fails
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • squash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Squashed Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This strategy squashes all your commit on a given branch with the --squash option
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • integrationBranch : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    What to specify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The branch name must match your integration branch name. No trailing slash.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merge is performed the following way

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Squash commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                git merge --squash <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                git commit -C <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Accumulated commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                git merge -m <commitMsg> <Branch matched by git> --no-ff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When changes are pushed to the integration branch?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Changes are only ever pushed when the build results is SUCCESS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                git push <Repository name> <Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    What to specify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The repository name. In git the repository is always the name of the remote. So if you have specified a repository name in your Git configuration. You need to specify the exact same name here, otherwise no integration will be performed. We do the merge based on this.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    No trailing slash on repository name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Remember to specify this when working with NAMED repositories in Git

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • pruneStaleBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • pruneStaleTag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketPublicRepoPullRequestFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If the repository being scanned is a public repository, this behaviour will exclude all pull requests. (Note: This behaviour is not especially useful if scanning a single repository as you could just not include the pull request discovery behaviours in the first place)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'PullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • excludeBranchesWithPRs : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Exclude branches for which there is an open pull request
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'PullRequestLabelsBlackListFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Filter github pull requests out by labels matching any labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'PullRequestLabelsMatchAllFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Filter github pull requests by labels matching all labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'PullRequestLabelsMatchAnyFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Filter github pull requests by labels matching any labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'PullRequestNameFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Filter Bitbucket Pull Requests by matching in title any phrase specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'PullRequestSourceBranchFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Filter Bitbucket Pull Requests by source branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'PullRequestTargetBranchFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Filter Bitbucket Pull Requests by target branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • refSpecs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • templates
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • value : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A ref spec to fetch. Any occurrences of @{remote} will be replaced by the remote name (which defaults to origin) before use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • headRegexFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • tagRegex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • giteaReleaseDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers releases on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • includePreReleases : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If enabled, releases that are marked as pre-release are also discovered
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • artifactToAssetMappingEnabled : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If enabled, artifacts that where archived (i.e. via archiveArtifacts) will be added as assets in the release, but only if the build was successfull.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • remoteName
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • remoteName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'ScmManagerBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nested Object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the paths that you'd like to sparse checkout. This may be used for saving space (Think about a reference repository). Be sure to use a recent version of Git, at least above 1.7.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • path : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • submoduleOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • disableSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            By disabling support for submodules you can still keep using basic git plugin functionality and just have Jenkins to ignore submodules completely as if they didn't exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • parentCredentials : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Use credentials from the default remote of the parent project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • recursiveSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Retrieve all submodules recursively (uses '--recursive' option which requires git>=1.6.5)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • reference : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            To prepare a reference folder with multiple subprojects, create a bare git repository and add all the remote urls then perform a fetch:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              git init --bare
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              git remote add SubProject1 https://gitrepo.com/subproject1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              git remote add SubProject2 https://gitrepo.com/subproject2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              git fetch --all
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • shallow : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • threads : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the number of threads that will be used to update submodules.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If unspecified, the command line git default thread count is used.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • timeout : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify a timeout (in minutes) for submodules operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • trackingSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Retrieve the tip of the configured branch in .gitmodules (Uses '--remote' option which requires git>=1.8.2)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • mrTriggerComment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • commentBody : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Add comment body you want to use to instruct Jenkins CI to rebuild the MR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • onlyTrustedMembersCanTrigger : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • tuleapBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • tuleapNotifyPullRequest
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • tuleapForkPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • tuleapPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • userIdentity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • name : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If given, "GIT_COMMITTER_NAME=[this]" and "GIT_AUTHOR_NAME=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • email : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If given, "GIT_COMMITTER_EMAIL=[this]" and "GIT_AUTHOR_EMAIL=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketWebhookConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Sets the value for committersToIgnore in the Bitbucket Webhook. Value should be a comma separated string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                committerToIgnore is used to prevent triggering Jenkins builds when commits by certain users are made.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • committersToIgnore : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • WebhookListenerBuildConditionsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • alwaysBuildMROpen : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • alwaysBuildMRReOpen : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • alwaysIgnoreMRApproval : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • alwaysIgnoreMRApproved : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • alwaysIgnoreMRUnApproval : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • alwaysIgnoreMRUnApproved : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • alwaysIgnoreMRWorkInProgress : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • alwaysIgnoreNonCodeRelatedUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  GitLab will send a webhook to Jenkins when there are updates to the MR including title changes, labels removed/added, etc. Enabling this option will prevent a build running if the cause was one of these updates. Note: these settings do not have any impact on build from comment settings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • headWildcardFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • tagIncludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • tagExcludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'WipeWorkspaceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers branches that have PR's associated with them. This may make sense if you have a notification sent to the team at the end of a triggered build or limited Jenkins resources.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Forks in the same account
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bitbucket allows for a repository to be forked into a "sibling" repository in the same account but using a different name. This strategy will trust any pull requests from forks that are in the same account as the target repository on the basis that users have to have been granted write permission to account in order create such a fork.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on Bitbucket Cloud.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        By default the discovered branches / pull requests will all use the same credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Credentials used to check out sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          It must be a SSH key based credential.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Manual webhook configuration requires the user to configure Bitbucket with the Jenkins URL in order to ensure that Bitbucket will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Bitbucket can connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The Manage Jenkins » Configure Jenkins › Bitbucket Endpoints allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • mode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            There are two available modes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Disable hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure Jenkins › Bitbucket Endpoints
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'com.cloudogu.scmmanager.scm.BranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'com.cloudogu.scmmanager.scm.TagDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • dagshubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.ForkPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.OriginPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • dagshubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitLabBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Only branches that are not also filed as MRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If you are discovering origin merge requests, it may not make sense to discover the same changes both as a merge request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Only branches that are also filed as MRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a merge request against this text.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ignores whether the branch is also filed as a merge request and instead discovers all branches on the origin project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • branchesAlwaysIncludedRegex : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Regular expression of branches that should always be included regardless of whether a merge request exists or not for those branches.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitLabSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  By default the discovered branches / merge requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitLabTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • headRegexFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • headWildcardFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Space-separated list of name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Space-separated list of name patterns to ignore even if matched by the includes list. For example: release alpha-* beta-*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • headRegexFilterWithPR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • tagRegex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • headWildcardFilterWithPR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • tagIncludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • tagExcludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • giteaBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a pull request against this text.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Only branches that are also filed as PRs or main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover branches that are also files as PRs (have open PRs) or that are the master / main branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • giteaForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Contributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of contributors to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on a Gitea instance that allows signup.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitLabTrustMembers
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitLabTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitLabTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitLabTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • giteaTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • giteaTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • giteaTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • giteaPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • giteaSSHCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • giteaTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • giteaWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Manual webhook configuration requires the user to configure Gitea with the Jenkins URL in order to ensure that Gitea will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Gitea can connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The Manage Jenkins » Configure System › Gitea Server allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • mode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        There are two available modes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Disable hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure System › Gitea Server
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If you are discovering origin pull requests, you may not want to also build the source branches for those pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Similar to discovering origin pull requests, but discovers the branch rather than the pull request. This means env.GIT_BRANCH will be set to the branch name rather than PR-#. Also, status notifications for these builds will only be applied to the commit and not to the pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Collaborators
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of collaborators to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody. NOTE: all collaborators are trusted, even if they are only members of a team with read permission.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on GitHub.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        From users with Admin or Write permission
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Pull requests forks will be treated as trusted if and only if the fork owner has either Admin or Write permissions on the origin repository. This is the recommended policy. Note that this strategy requires the Review a user's permission level API, as a result on GitHub Enterprise Server versions before 2.12 this is the same as trusting Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • type (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Values: Branches, MergeRequests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • multiStreams
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'SubversionSCMSource'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • multiSwarm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Tuleap
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • BbS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • credentialsId : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When running a job, Jenkins requires credentials to authenticate with Bitbucket Server. For example, to checkout the source code for builds. To do this, it needs credentials with access to the projects and repositories you want it to build from.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              You can provide Jenkins with credentials here by:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • selecting credentials from the list
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • adding credentials as a Username with password (for the password, you can enter a Bitbucket Server password or a Bitbucket Server personal access token)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              In addition, you can provide Jenkins with SSH credentials below. If you do, Jenkins will use them for clone operations instead of the credentials you select here.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • sshCredentialsId : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              If specified, Jenkins will use these credentials to check out the source code for builds. If no SSH credentials are specified, Jenkins will use the basic credentials instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              To provide Jenkins with SSH credentials, you can:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • choose credentials from the list
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • add credentials as a SSH Username with private key (the username must be "git")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • traits
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'ApprovedPullRequestTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  No approval necessary.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  No check of approvals will be performed before building.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Any approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Before building the pull request must be approved. This may be performed by the author or someone else.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Non-author approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Before building the pull request must be approved and that approval cannot be performed by the author of the pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Author and Non-author approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Before building the pull request must be approved by the author and a non-author.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • authorInChangelog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'BitbucketBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers branches in the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketBuildStatusNotifications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Configure the Bitbucket notifications.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • disableNotificationForNotBuildJobs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • sendSuccessNotificationForUnstableBuild : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'BitbucketGitBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • assembla
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • cgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • fisheye
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitblit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitLab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • kiln
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • phabricator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repo : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • redmine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • jbSpace
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Provide the absolute URL to your repository in JetBrains SpaceCode in the following format: https://<your SpaceCode instance>/p/<project key>/repositories/<repository name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • viewgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'BitbucketJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'BitbucketPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers open pull requests in the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • buildStatusNameCustomPart
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Customize the pipeline status name used by Jenkins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • buildStatusNameCustomPart : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enter a string to customize the status/context name for status updates published to GitLab. For a branch build the default name would be 'jenkinsci/branch'. With the buildStatusNameCustomPart 'custom' the name would be 'jenkinsci/custom/branch'. This allows to have multiple GitLab-Branch-Sources for the same GitLab-project configured.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • buildStatusNameOverwrite : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Overwrites the build status name including the jenkinsci default part.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Instead of 'jenkinsci/custom/branch' just 'custom/branch'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • ignoreTypeInStatusName : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'ChangeDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • queryString : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Provide an additional query string to search for open changes. The status:open is implicitly added and does not need to be specified. See Gerrit search operators documentation for a detailed list of the supported search operators.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Examples:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • -is:wip
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                does not include work-in-progress changes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • is:private
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                includes private changes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • checkoutOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify a timeout (in minutes) for checkout.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • cleanAfterCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Clean up the workspace after every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • cleanBeforeCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Clean up the workspace before every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'CleanMercurialSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            When this behaviour is present, each build will wipe any local modifications or untracked files in the repository checkout. This is often a convenient way to ensure that a build is not using any artifacts from earlier builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • cloneOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • shallow : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • noTags : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Deselect this to perform a clone without tags, saving time and disk space when you just want to access what is specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • reference : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify a timeout (in minutes) for clone and fetch operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • honorRefspec : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Perform initial clone using the refspec defined for the repository. This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'DisableStatusUpdateTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Disables notifications (commit status updates) to GitHub for builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • discoverOtherRefs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers other specified refs on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • ref : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The pattern under /refs on the remote repository to discover, can contain a wildcard.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Example: test/*/merged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • nameMapping : String (optional)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Mapping for how the ref can be named in for example the @Library.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Example: test-@{1}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Where @{1} replaces the first wildcard in the ref when discovered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  By default it will be "namespace_before_wildcard-@{1}". E.g. if ref is "test/*/merged" the default mapping would be "test-@{1}".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'FilterChecksTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • queryOperator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Values: ID, SCHEME
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • queryString : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Provide a query string to search for pending checks. Depending on which mode was chosen, this either should be a checker-scheme or the UUID of a specific checker.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitLabForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers merge requests where the origin project is a fork of the target project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  One of the great powers of merge requests is that anyone with read access to a project can fork it, commit some changes to their fork and then create a merge request against the original project with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox merge requests in order to mitigate against malicious merge requests. In order to protect against a malicious merge request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for merge requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merge requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin project and not from the merge request branch on the fork project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Members
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merge requests from collaborators to the origin project will be treated as trusted, all other merge requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the project does not have permission to query the list of contributors to the origin project then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Trusted Members
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merge requests forks will be treated as trusted if and only if the fork owner has either Developer or Maintainer or Owner Access Level in the origin project. This is the recommended policy.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  All merge requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public project hosted on a GitLab instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Type: jenkins.scm.api.trait.SCMHeadAuthority<? super io.jenkins.plugins.gitlabbranchsource.GitLabSCMSourceRequest, ? extends jenkins.scm.api.mixin.ChangeRequestSCMHead2, ? extends jenkins.scm.api.SCMRevision>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • buildMRForksNotMirror : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Add discovery of merge requests where the origin project is a fork of a certain project, but the target project is not the original forked project. To be used in case one has a GitLab project which is a fork of another project from another team, in order to isolate artefacts and allow an MR flow. This means using MRs inside that fork from branches in the fork back to the fork's default branch. (Implements https://github.com/jenkinsci/gitlab-branch-source-plugin/issues/167)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • assembla
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • cgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • fisheye
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitblit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitLab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • kiln
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • phabricator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repo : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • redmine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • jbSpace
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Provide the absolute URL to your repository in JetBrains SpaceCode in the following format: https://<your SpaceCode instance>/p/<project key>/repositories/<repository name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • viewgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'GitHubJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubSourceChecks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • verboseConsoleLog : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If this option is checked, verbose log will be output to build console; the verbose log is useful for debugging the publisher creation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubStatusChecks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • name : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • skip : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • skipNotifications : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If this option is checked, the notifications sent by the GitHub Branch Source Plugin will be disabled.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • skipProgressUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • suppressLogs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • unstableBuildNeutral : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • lfs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitlabAvatar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • disableProjectAvatar : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Due to a GitLab bug, sometimes it is not possible to GitLab API to fetch GitLab Avatar for private projects or when the api doesn't have token access. You may choose to skip avatar for projects if you want to avoid broken or self generated avatars.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitlabMarkUnstableAsSuccess
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • markUnstableAsSuccess : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitlabSkipNotifications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitTool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitTool : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitLabHookRegistration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • webHookMode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • systemHookMode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubIgnoreDraftPullRequestFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • ignoreOnPush
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • jervisFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This will look at the root of a GitHub reference for .jervis.yml for the branches and tags filtering. You can customize the name of the YAML file searched for if you like.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For Tags:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • It will filter for the tag name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For Branches:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • It will filter for the branch name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • It will filter for pull requests destined for the branch name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Example YAML

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              More on specify branches and tags to build

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              By default Jervis will generate Jenkins jobs for all branches that have a .jervis.yml file. You can control and limit this behavior by specifying the branches or tags key in your .jervis.yml.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Allow or block branches and tags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              You can either create an allow list of branches (only) or a block list of branches (except) to be built.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              # block branches from building
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                except:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - legacy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - experimental
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              # allow only these branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - stable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The same YAML can be applied to tags.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              # block tags from building
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tags:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                except:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - .*-rc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - .*-beta
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              # allow only these tags
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tags:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - v[.0-9]+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              If you specify both only and except, then except will be ignored. .jervis.yml needs to be present on all branches you want to be built. .jervis.yml will be interpreted in the context of that branch so if you specify an allow list in your main branch, then it will not propagate to other branches.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Using regular expressions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              You can use regular expressions to allow or block branches:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - /^[.0-9]+-hotfix$/
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Any name surrounded with / in the list of branches is treated as a regular expression. The expression will use Pattern.compile to compile the regex string into a Groovy regular expression.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • yamlFileName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The filename which will be read from GitHub to determine if a Jenkins branch, tag, or pull request should be built. Provide a comma separated list of paths to YAML files in a repository and it will check each path as a fallback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For example, set the value to: .jervis.yml, .ci/jervis.yml and this plugin will first check for valid YAML in .jervis.yml. If no YAML exists, then it will fall back to checking .ci/jervis.yml.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • localBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • logComment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • logSuccess : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Sometimes the user doesn't want to log the builds that succeeded. The trait only enable logging of failed/aborted builds by default. Select this option to include logging of successful builds as well.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • sudoUser : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enter a sudo username of the user you want to comment as on GitLab Server. Remember the token specified should have api and sudo access both (which can only be created by your GitLab Server Admin). It is recommended to create a dummy user in your GitLab Server with an appropriate username like `jenkinsadmin` etc. Leave empty if you want use the owner of the project as the commenter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'MercurialBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'FishEye'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository, such as: http://www.example.org/browse/hg/
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'GoogleCode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'HgWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'Kallithea'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'KilnHG'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'RhodeCode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'RhodeCodeLegacy'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'ScmManager'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as http://YOURSCMMANAGER/scm/repo/NAMESPACE/NAME/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'MercurialInstallationSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • installation : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • multiBranchProjectDisplayNaming
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some branch source plugins provide additional information about discovered branches like a title or subject of merge or change requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                With this trait, that additional information can be used for the job display names.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Note: Job display name changes do not trigger builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • displayNamingStrategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The different strategies:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Job display name with fallback to name:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Uses the branch source plugin's display name for the PR instead of the raw name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Value for configuration-as-code: OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Name and, if available, display name:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Joins the raw name and the branch source plugin's display name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Value for configuration-as-code: RAW_AND_OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Values: OBJECT_DISPLAY_NAME, RAW_AND_OBJECT_DISPLAY_NAME
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubNotificationContextTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Defines custom context labels to be sent as part of GitHub Status notifications for this project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • contextLabel : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The text of the context label(s) for GitHub status notifications. If using multiple statuses, entries are separated by the specified delimiter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • typeSuffix : boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Appends the relevant suffix to the context label(s) based on the build type. '/pr-merge', '/pr-head' or '/branch'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • multipleStatusDelimiter : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The separator/delimiter used for splitting the Label field into multiple values.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • multipleStatuses : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Configure multiple status notifications to be sent to GitHub.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitLabOriginDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers merge requests where the origin project is the same as the target project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'PathBasedPullRequestFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • inclusionField : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If any of the changed files in a discovered PR match this regex then it will generate a build (unless excluded by the exclusion regex).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • exclusionField : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Any changed files in a discovered pull request that matches this regex will not be considered for the inclusion regex.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'PreBuildMergeTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    These options allow you to perform a merge to a particular branch before building. For example, you could specify an integration branch to be built, and to merge to master. In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful. It then may push the merge back to the remote repository if the Git Push post-build action is selected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • mergeTarget : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The name of the branch within the named repository to merge to, such as master.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • fastForwardMode (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merge fast-forward mode selection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The default, --ff, gracefully falls back to a merge commit when required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      For more information, see the Git Merge Documentation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Values: FF, FF_ONLY, NO_FF
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • mergeRemote : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Name of the repository, such as origin, that contains the branch you specify below. If left blank, it'll default to the name of the first repository configured above.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • mergeStrategy (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merge strategy selection. This feature is not fully implemented in JGIT.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Values: DEFAULT, RESOLVE, RECURSIVE, OCTOPUS, OURS, SUBTREE, RECURSIVE_THEIRS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'PretestedIntegrationSCMTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitIntegrationStrategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • accumulated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Accumulated Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This strategy merges your commits with the --no-ff switch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ffonly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Fast Forward only (--ff-only) Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This strategy fast-forward only using the --ff-only switch - or fails
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • squash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Squashed Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This strategy squashes all your commit on a given branch with the --squash option
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • integrationBranch : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      What to specify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The branch name must match your integration branch name. No trailing slash.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merge is performed the following way

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Squash commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git merge --squash <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git commit -C <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Accumulated commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git merge -m <commitMsg> <Branch matched by git> --no-ff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      When changes are pushed to the integration branch?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Changes are only ever pushed when the build results is SUCCESS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git push <Repository name> <Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      What to specify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The repository name. In git the repository is always the name of the remote. So if you have specified a repository name in your Git configuration. You need to specify the exact same name here, otherwise no integration will be performed. We do the merge based on this.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      No trailing slash on repository name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Remember to specify this when working with NAMED repositories in Git

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • pruneStaleBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • pruneStaleTag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketPublicRepoPullRequestFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If the repository being scanned is a public repository, this behaviour will exclude all pull requests. (Note: This behaviour is not especially useful if scanning a single repository as you could just not include the pull request discovery behaviours in the first place)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'PullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • excludeBranchesWithPRs : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Exclude branches for which there is an open pull request
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'PullRequestLabelsBlackListFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Filter github pull requests out by labels matching any labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'PullRequestLabelsMatchAllFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Filter github pull requests by labels matching all labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'PullRequestLabelsMatchAnyFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Filter github pull requests by labels matching any labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'PullRequestNameFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Filter Bitbucket Pull Requests by matching in title any phrase specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'PullRequestSourceBranchFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Filter Bitbucket Pull Requests by source branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'PullRequestTargetBranchFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Filter Bitbucket Pull Requests by target branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • refSpecs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • templates
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • value : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A ref spec to fetch. Any occurrences of @{remote} will be replaced by the remote name (which defaults to origin) before use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • headRegexFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • tagRegex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • giteaReleaseDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers releases on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • includePreReleases : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If enabled, releases that are marked as pre-release are also discovered
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • artifactToAssetMappingEnabled : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If enabled, artifacts that where archived (i.e. via archiveArtifacts) will be added as assets in the release, but only if the build was successfull.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • remoteName
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • remoteName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'ScmManagerBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the paths that you'd like to sparse checkout. This may be used for saving space (Think about a reference repository). Be sure to use a recent version of Git, at least above 1.7.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • path : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • submoduleOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • disableSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              By disabling support for submodules you can still keep using basic git plugin functionality and just have Jenkins to ignore submodules completely as if they didn't exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • parentCredentials : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Use credentials from the default remote of the parent project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • recursiveSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Retrieve all submodules recursively (uses '--recursive' option which requires git>=1.6.5)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • reference : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              To prepare a reference folder with multiple subprojects, create a bare git repository and add all the remote urls then perform a fetch:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                git init --bare
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                git remote add SubProject1 https://gitrepo.com/subproject1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                git remote add SubProject2 https://gitrepo.com/subproject2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                git fetch --all
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • shallow : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • threads : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the number of threads that will be used to update submodules.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              If unspecified, the command line git default thread count is used.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • timeout : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify a timeout (in minutes) for submodules operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • trackingSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Retrieve the tip of the configured branch in .gitmodules (Uses '--remote' option which requires git>=1.8.2)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • mrTriggerComment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • commentBody : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Add comment body you want to use to instruct Jenkins CI to rebuild the MR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • onlyTrustedMembersCanTrigger : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • tuleapBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • tuleapNotifyPullRequest
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • tuleapForkPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • tuleapPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • userIdentity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • name : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If given, "GIT_COMMITTER_NAME=[this]" and "GIT_AUTHOR_NAME=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • email : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If given, "GIT_COMMITTER_EMAIL=[this]" and "GIT_AUTHOR_EMAIL=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketWebhookConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Sets the value for committersToIgnore in the Bitbucket Webhook. Value should be a comma separated string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  committerToIgnore is used to prevent triggering Jenkins builds when commits by certain users are made.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • committersToIgnore : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • WebhookListenerBuildConditionsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • alwaysBuildMROpen : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • alwaysBuildMRReOpen : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • alwaysIgnoreMRApproval : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • alwaysIgnoreMRApproved : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • alwaysIgnoreMRUnApproval : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • alwaysIgnoreMRUnApproved : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • alwaysIgnoreMRWorkInProgress : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • alwaysIgnoreNonCodeRelatedUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GitLab will send a webhook to Jenkins when there are updates to the MR including title changes, labels removed/added, etc. Enabling this option will prevent a build running if the cause was one of these updates. Note: these settings do not have any impact on build from comment settings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • headWildcardFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • tagIncludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • tagExcludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'WipeWorkspaceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers branches that have PR's associated with them. This may make sense if you have a notification sent to the team at the end of a triggered build or limited Jenkins resources.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Forks in the same account
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Bitbucket allows for a repository to be forked into a "sibling" repository in the same account but using a different name. This strategy will trust any pull requests from forks that are in the same account as the target repository on the basis that users have to have been granted write permission to account in order create such a fork.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on Bitbucket Cloud.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          By default the discovered branches / pull requests will all use the same credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Credentials used to check out sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            It must be a SSH key based credential.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Manual webhook configuration requires the user to configure Bitbucket with the Jenkins URL in order to ensure that Bitbucket will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Bitbucket can connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The Manage Jenkins » Configure Jenkins › Bitbucket Endpoints allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • mode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              There are two available modes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Disable hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure Jenkins › Bitbucket Endpoints
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'com.cloudogu.scmmanager.scm.BranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'com.cloudogu.scmmanager.scm.TagDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • dagshubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.ForkPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.OriginPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • dagshubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitLabBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Only branches that are not also filed as MRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If you are discovering origin merge requests, it may not make sense to discover the same changes both as a merge request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Only branches that are also filed as MRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a merge request against this text.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Ignores whether the branch is also filed as a merge request and instead discovers all branches on the origin project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • branchesAlwaysIncludedRegex : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Regular expression of branches that should always be included regardless of whether a merge request exists or not for those branches.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitLabSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default the discovered branches / merge requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitLabTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • headRegexFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • headWildcardFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Space-separated list of name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Space-separated list of name patterns to ignore even if matched by the includes list. For example: release alpha-* beta-*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • headRegexFilterWithPR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • tagRegex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • headWildcardFilterWithPR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • tagIncludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • tagExcludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • giteaBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a pull request against this text.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Only branches that are also filed as PRs or main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover branches that are also files as PRs (have open PRs) or that are the master / main branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • giteaForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Contributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of contributors to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on a Gitea instance that allows signup.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitLabTrustMembers
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitLabTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitLabTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitLabTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • giteaTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • giteaTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • giteaTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • giteaPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • giteaSSHCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • giteaTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • giteaWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Manual webhook configuration requires the user to configure Gitea with the Jenkins URL in order to ensure that Gitea will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Gitea can connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The Manage Jenkins » Configure System › Gitea Server allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • mode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          There are two available modes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Disable hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure System › Gitea Server
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitHubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If you are discovering origin pull requests, you may not want to also build the source branches for those pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Similar to discovering origin pull requests, but discovers the branch rather than the pull request. This means env.GIT_BRANCH will be set to the branch name rather than PR-#. Also, status notifications for these builds will only be applied to the commit and not to the pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitHubForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Collaborators
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of collaborators to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody. NOTE: all collaborators are trusted, even if they are only members of a team with read permission.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on GitHub.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          From users with Admin or Write permission
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Pull requests forks will be treated as trusted if and only if the fork owner has either Admin or Write permissions on the origin repository. This is the recommended policy. Note that this strategy requires the Review a user's permission level API, as a result on GitHub Enterprise Server versions before 2.12 this is the same as trusting Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • projectName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enter the name of the Bitbucket Server project containing the repository you want Jenkins to build from. To find a project, start typing. If it doesn't appear in the search results, the credentials that you've chosen may not have read access to it and you'll need to provide different credentials.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                To get Jenkins to build from a personal repository, enter a tilde (~) followed by repository owner's username. For example, ~jsmith.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repositoryName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enter the Bitbucket Server repository you want Jenkins to build from. To find a repository, start typing. If it doesn't appear in the search results, the credentials that you've chosen may not have read access to it and you'll need to provide different credentials.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                To get Jenkins to build from a personal repository, enter its slug. This is the URL-friendly version of the repository name. For example, a repository called my example repo will have the slug my-example-repo, and you can see this in its URL, https://bitbucketserver.mycompany.com/myproject/my-example-repo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • serverId : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Choose the Bitbucket Server instance containing the repository you want Jenkins to build from. If you can't find your instance, check this plugin's configuration and try again.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • mirrorName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Choose the location that Jenkins should clone from when running this build. This can be the primary server or a mirror if one is available. To see available mirrors, first choose a Bitbucket Server project and repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • id : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discovers branches and/or pull requests from a specific repository in either Bitbucket Cloud or a Bitbucket Server instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoOwner : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the name of the Bitbucket Team or Bitbucket User Account.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                It could be a Bitbucket Project also, if using Bitbucket Server. In this case (Bitbucket Server):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use the project key, not the project name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • If using a user account instead of a project, add a "~" character before the username, i.e. "~joe".
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repository : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The repository to scan.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • autoRegisterHook : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • bitbucketServerUrl : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • checkoutCredentialsId : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • credentialsId : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Credentials used to scan branches (also the default credentials to use when checking out sources).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For security reasons most credentials are only available when HTTPS is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • excludes : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • id : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • includes : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • mirrorId : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The location Jenkins should clone from. This can be the primary server or a mirror if one is available.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • serverUrl : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The server to connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The list of servers is configured in the Manage Jenkins » Configure Jenkins › Bitbucket Endpoints screen. The list of servers can include both Bitbucket Cloud and Bitbucket Server instances.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • traits (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The behaviours control what is discovered from the Bitbucket repository. The behaviours are grouped into a number of categories:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Within repository
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                These behaviours determine what gets discovered. If you do not configure at least one discovery behaviour then nothing will be found!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                General
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                These behaviours affect the configuration of each discovered branch / pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Git
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                These behaviours affect the configuration of each discovered branch / pull request and are specific to Git semantics.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'ApprovedPullRequestTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    No approval necessary.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    No check of approvals will be performed before building.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Any approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Before building the pull request must be approved. This may be performed by the author or someone else.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Non-author approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Before building the pull request must be approved and that approval cannot be performed by the author of the pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Author and Non-author approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Before building the pull request must be approved by the author and a non-author.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • authorInChangelog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'BitbucketBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers branches in the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketBuildStatusNotifications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Configure the Bitbucket notifications.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • disableNotificationForNotBuildJobs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • sendSuccessNotificationForUnstableBuild : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'BitbucketGitBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • assembla
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • cgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • fisheye
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitblit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitLab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • kiln
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • phabricator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repo : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • redmine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • jbSpace
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Provide the absolute URL to your repository in JetBrains SpaceCode in the following format: https://<your SpaceCode instance>/p/<project key>/repositories/<repository name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • viewgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'BitbucketJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'BitbucketPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discovers open pull requests in the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • buildStatusNameCustomPart
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Customize the pipeline status name used by Jenkins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • buildStatusNameCustomPart : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enter a string to customize the status/context name for status updates published to GitLab. For a branch build the default name would be 'jenkinsci/branch'. With the buildStatusNameCustomPart 'custom' the name would be 'jenkinsci/custom/branch'. This allows to have multiple GitLab-Branch-Sources for the same GitLab-project configured.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • buildStatusNameOverwrite : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Overwrites the build status name including the jenkinsci default part.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Instead of 'jenkinsci/custom/branch' just 'custom/branch'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • ignoreTypeInStatusName : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'ChangeDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • queryString : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Provide an additional query string to search for open changes. The status:open is implicitly added and does not need to be specified. See Gerrit search operators documentation for a detailed list of the supported search operators.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Examples:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • -is:wip
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  does not include work-in-progress changes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • is:private
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  includes private changes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • checkoutOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specify a timeout (in minutes) for checkout.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • cleanAfterCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Clean up the workspace after every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • cleanBeforeCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Clean up the workspace before every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'CleanMercurialSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When this behaviour is present, each build will wipe any local modifications or untracked files in the repository checkout. This is often a convenient way to ensure that a build is not using any artifacts from earlier builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • cloneOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • shallow : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • noTags : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deselect this to perform a clone without tags, saving time and disk space when you just want to access what is specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • reference : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify a timeout (in minutes) for clone and fetch operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • honorRefspec : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Perform initial clone using the refspec defined for the repository. This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'DisableStatusUpdateTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Disables notifications (commit status updates) to GitHub for builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • discoverOtherRefs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers other specified refs on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ref : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The pattern under /refs on the remote repository to discover, can contain a wildcard.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Example: test/*/merged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • nameMapping : String (optional)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Mapping for how the ref can be named in for example the @Library.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Example: test-@{1}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Where @{1} replaces the first wildcard in the ref when discovered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default it will be "namespace_before_wildcard-@{1}". E.g. if ref is "test/*/merged" the default mapping would be "test-@{1}".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'FilterChecksTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • queryOperator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Values: ID, SCHEME
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • queryString : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Provide a query string to search for pending checks. Depending on which mode was chosen, this either should be a checker-scheme or the UUID of a specific checker.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitLabForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers merge requests where the origin project is a fork of the target project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    One of the great powers of merge requests is that anyone with read access to a project can fork it, commit some changes to their fork and then create a merge request against the original project with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox merge requests in order to mitigate against malicious merge requests. In order to protect against a malicious merge request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for merge requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merge requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin project and not from the merge request branch on the fork project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Members
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merge requests from collaborators to the origin project will be treated as trusted, all other merge requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the project does not have permission to query the list of contributors to the origin project then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Trusted Members
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merge requests forks will be treated as trusted if and only if the fork owner has either Developer or Maintainer or Owner Access Level in the origin project. This is the recommended policy.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    All merge requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public project hosted on a GitLab instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Type: jenkins.scm.api.trait.SCMHeadAuthority<? super io.jenkins.plugins.gitlabbranchsource.GitLabSCMSourceRequest, ? extends jenkins.scm.api.mixin.ChangeRequestSCMHead2, ? extends jenkins.scm.api.SCMRevision>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • buildMRForksNotMirror : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Add discovery of merge requests where the origin project is a fork of a certain project, but the target project is not the original forked project. To be used in case one has a GitLab project which is a fork of another project from another team, in order to isolate artefacts and allow an MR flow. This means using MRs inside that fork from branches in the fork back to the fork's default branch. (Implements https://github.com/jenkinsci/gitlab-branch-source-plugin/issues/167)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • assembla
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • cgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • fisheye
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitblit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitLab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • kiln
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • phabricator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repo : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • redmine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • jbSpace
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Provide the absolute URL to your repository in JetBrains SpaceCode in the following format: https://<your SpaceCode instance>/p/<project key>/repositories/<repository name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • viewgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'GitHubJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitHubSourceChecks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • verboseConsoleLog : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If this option is checked, verbose log will be output to build console; the verbose log is useful for debugging the publisher creation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitHubStatusChecks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • name : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • skip : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • skipNotifications : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If this option is checked, the notifications sent by the GitHub Branch Source Plugin will be disabled.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • skipProgressUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • suppressLogs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • unstableBuildNeutral : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • lfs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitlabAvatar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • disableProjectAvatar : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Due to a GitLab bug, sometimes it is not possible to GitLab API to fetch GitLab Avatar for private projects or when the api doesn't have token access. You may choose to skip avatar for projects if you want to avoid broken or self generated avatars.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitlabMarkUnstableAsSuccess
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • markUnstableAsSuccess : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitlabSkipNotifications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitTool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitTool : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitLabHookRegistration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • webHookMode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • systemHookMode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitHubIgnoreDraftPullRequestFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • ignoreOnPush
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • jervisFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This will look at the root of a GitHub reference for .jervis.yml for the branches and tags filtering. You can customize the name of the YAML file searched for if you like.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For Tags:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • It will filter for the tag name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For Branches:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • It will filter for the branch name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • It will filter for pull requests destined for the branch name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Example YAML

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                More on specify branches and tags to build

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                By default Jervis will generate Jenkins jobs for all branches that have a .jervis.yml file. You can control and limit this behavior by specifying the branches or tags key in your .jervis.yml.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Allow or block branches and tags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                You can either create an allow list of branches (only) or a block list of branches (except) to be built.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                # block branches from building
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  except:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - legacy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - experimental
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                # allow only these branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - stable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The same YAML can be applied to tags.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                # block tags from building
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tags:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  except:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - .*-rc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - .*-beta
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                # allow only these tags
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tags:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - v[.0-9]+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If you specify both only and except, then except will be ignored. .jervis.yml needs to be present on all branches you want to be built. .jervis.yml will be interpreted in the context of that branch so if you specify an allow list in your main branch, then it will not propagate to other branches.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Using regular expressions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                You can use regular expressions to allow or block branches:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  only:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - /^[.0-9]+-hotfix$/
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Any name surrounded with / in the list of branches is treated as a regular expression. The expression will use Pattern.compile to compile the regex string into a Groovy regular expression.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • yamlFileName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The filename which will be read from GitHub to determine if a Jenkins branch, tag, or pull request should be built. Provide a comma separated list of paths to YAML files in a repository and it will check each path as a fallback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For example, set the value to: .jervis.yml, .ci/jervis.yml and this plugin will first check for valid YAML in .jervis.yml. If no YAML exists, then it will fall back to checking .ci/jervis.yml.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • localBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • logComment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • logSuccess : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sometimes the user doesn't want to log the builds that succeeded. The trait only enable logging of failed/aborted builds by default. Select this option to include logging of successful builds as well.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • sudoUser : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enter a sudo username of the user you want to comment as on GitLab Server. Remember the token specified should have api and sudo access both (which can only be created by your GitLab Server Admin). It is recommended to create a dummy user in your GitLab Server with an appropriate username like `jenkinsadmin` etc. Leave empty if you want use the owner of the project as the commenter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'MercurialBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'FishEye'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository, such as: http://www.example.org/browse/hg/
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'GoogleCode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'HgWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'Kallithea'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'KilnHG'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'RhodeCode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'RhodeCodeLegacy'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as this).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'ScmManager'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as http://YOURSCMMANAGER/scm/repo/NAMESPACE/NAME/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'MercurialInstallationSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • installation : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • multiBranchProjectDisplayNaming
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Some branch source plugins provide additional information about discovered branches like a title or subject of merge or change requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  With this trait, that additional information can be used for the job display names.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Note: Job display name changes do not trigger builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • displayNamingStrategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The different strategies:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Job display name with fallback to name:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Uses the branch source plugin's display name for the PR instead of the raw name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Value for configuration-as-code: OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Name and, if available, display name:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Joins the raw name and the branch source plugin's display name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Value for configuration-as-code: RAW_AND_OBJECT_DISPLAY_NAME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Values: OBJECT_DISPLAY_NAME, RAW_AND_OBJECT_DISPLAY_NAME
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubNotificationContextTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Defines custom context labels to be sent as part of GitHub Status notifications for this project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • contextLabel : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The text of the context label(s) for GitHub status notifications. If using multiple statuses, entries are separated by the specified delimiter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • typeSuffix : boolean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Appends the relevant suffix to the context label(s) based on the build type. '/pr-merge', '/pr-head' or '/branch'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • multipleStatusDelimiter : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The separator/delimiter used for splitting the Label field into multiple values.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • multipleStatuses : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Configure multiple status notifications to be sent to GitHub.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitLabOriginDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers merge requests where the origin project is the same as the target project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'PathBasedPullRequestFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • inclusionField : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If any of the changed files in a discovered PR match this regex then it will generate a build (unless excluded by the exclusion regex).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • exclusionField : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Any changed files in a discovered pull request that matches this regex will not be considered for the inclusion regex.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'PreBuildMergeTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      These options allow you to perform a merge to a particular branch before building. For example, you could specify an integration branch to be built, and to merge to master. In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful. It then may push the merge back to the remote repository if the Git Push post-build action is selected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • mergeTarget : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The name of the branch within the named repository to merge to, such as master.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • fastForwardMode (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Merge fast-forward mode selection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The default, --ff, gracefully falls back to a merge commit when required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For more information, see the Git Merge Documentation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Values: FF, FF_ONLY, NO_FF
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • mergeRemote : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Name of the repository, such as origin, that contains the branch you specify below. If left blank, it'll default to the name of the first repository configured above.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • mergeStrategy (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Merge strategy selection. This feature is not fully implemented in JGIT.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Values: DEFAULT, RESOLVE, RECURSIVE, OCTOPUS, OURS, SUBTREE, RECURSIVE_THEIRS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'PretestedIntegrationSCMTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitIntegrationStrategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • accumulated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Accumulated Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This strategy merges your commits with the --no-ff switch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ffonly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fast Forward only (--ff-only) Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This strategy fast-forward only using the --ff-only switch - or fails
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • squash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Squashed Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This strategy squashes all your commit on a given branch with the --squash option
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • integrationBranch : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        What to specify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The branch name must match your integration branch name. No trailing slash.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Merge is performed the following way

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Squash commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git merge --squash <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git commit -C <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Accumulated commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git merge -m <commitMsg> <Branch matched by git> --no-ff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        When changes are pushed to the integration branch?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Changes are only ever pushed when the build results is SUCCESS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git push <Repository name> <Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        What to specify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The repository name. In git the repository is always the name of the remote. So if you have specified a repository name in your Git configuration. You need to specify the exact same name here, otherwise no integration will be performed. We do the merge based on this.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        No trailing slash on repository name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Remember to specify this when working with NAMED repositories in Git

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • pruneStaleBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • pruneStaleTag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketPublicRepoPullRequestFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If the repository being scanned is a public repository, this behaviour will exclude all pull requests. (Note: This behaviour is not especially useful if scanning a single repository as you could just not include the pull request discovery behaviours in the first place)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'PullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • excludeBranchesWithPRs : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Exclude branches for which there is an open pull request
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'PullRequestLabelsBlackListFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Filter github pull requests out by labels matching any labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'PullRequestLabelsMatchAllFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Filter github pull requests by labels matching all labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'PullRequestLabelsMatchAnyFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Filter github pull requests by labels matching any labels specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • labels : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Labels to match a pull request. Use ',' to split multiple labels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'PullRequestNameFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Filter Bitbucket Pull Requests by matching in title any phrase specified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'PullRequestSourceBranchFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Filter Bitbucket Pull Requests by source branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'PullRequestTargetBranchFilterTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Filter Bitbucket Pull Requests by target branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • phrase : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Phrases to match a title of the pull request. Use ',' to split multiple phrases - only for no regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • ignoreCase : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Case sensitivity defines whether uppercase and lowercase letters are treated as distinct (unchecked) or equivalent (checked).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • regex : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Treat a phrase as a regular expression. Note, the comma character is part of the expression!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • refSpecs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • templates
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • value : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              A ref spec to fetch. Any occurrences of @{remote} will be replaced by the remote name (which defaults to origin) before use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • headRegexFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • tagRegex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • giteaReleaseDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers releases on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • includePreReleases : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If enabled, releases that are marked as pre-release are also discovered
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • artifactToAssetMappingEnabled : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If enabled, artifacts that where archived (i.e. via archiveArtifacts) will be added as assets in the release, but only if the build was successfull.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • remoteName
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • remoteName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'ScmManagerBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the paths that you'd like to sparse checkout. This may be used for saving space (Think about a reference repository). Be sure to use a recent version of Git, at least above 1.7.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • path : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • submoduleOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • disableSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                By disabling support for submodules you can still keep using basic git plugin functionality and just have Jenkins to ignore submodules completely as if they didn't exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • parentCredentials : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Use credentials from the default remote of the parent project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • recursiveSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Retrieve all submodules recursively (uses '--recursive' option which requires git>=1.6.5)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • reference : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                To prepare a reference folder with multiple subprojects, create a bare git repository and add all the remote urls then perform a fetch:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git init --bare
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git remote add SubProject1 https://gitrepo.com/subproject1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git remote add SubProject2 https://gitrepo.com/subproject2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git fetch --all
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • shallow : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • threads : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify the number of threads that will be used to update submodules.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If unspecified, the command line git default thread count is used.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • timeout : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specify a timeout (in minutes) for submodules operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • trackingSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Retrieve the tip of the configured branch in .gitmodules (Uses '--remote' option which requires git>=1.8.2)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • mrTriggerComment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • commentBody : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Add comment body you want to use to instruct Jenkins CI to rebuild the MR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • onlyTrustedMembersCanTrigger : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • tuleapBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • tuleapNotifyPullRequest
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • tuleapForkPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • tuleapPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • userIdentity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • name : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If given, "GIT_COMMITTER_NAME=[this]" and "GIT_AUTHOR_NAME=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • email : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If given, "GIT_COMMITTER_EMAIL=[this]" and "GIT_AUTHOR_EMAIL=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketWebhookConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Sets the value for committersToIgnore in the Bitbucket Webhook. Value should be a comma separated string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    committerToIgnore is used to prevent triggering Jenkins builds when commits by certain users are made.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • committersToIgnore : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • WebhookListenerBuildConditionsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • alwaysBuildMROpen : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • alwaysBuildMRReOpen : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • alwaysIgnoreMRApproval : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • alwaysIgnoreMRApproved : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • alwaysIgnoreMRUnApproval : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • alwaysIgnoreMRUnApproved : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • alwaysIgnoreMRWorkInProgress : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • alwaysIgnoreNonCodeRelatedUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GitLab will send a webhook to Jenkins when there are updates to the MR including title changes, labels removed/added, etc. Enabling this option will prevent a build running if the cause was one of these updates. Note: these settings do not have any impact on build from comment settings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • headWildcardFilterWithPRFromOrigin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • tagIncludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • tagExcludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'WipeWorkspaceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers branches that have PR's associated with them. This may make sense if you have a notification sent to the team at the end of a triggered build or limited Jenkins resources.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Forks in the same account
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Bitbucket allows for a repository to be forked into a "sibling" repository in the same account but using a different name. This strategy will trust any pull requests from forks that are in the same account as the target repository on the basis that users have to have been granted write permission to account in order create such a fork.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on Bitbucket Cloud.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Determines how pull requests are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            By default the discovered branches / pull requests will all use the same credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Credentials used to check out sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              It must be a SSH key based credential.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Manual webhook configuration requires the user to configure Bitbucket with the Jenkins URL in order to ensure that Bitbucket will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Bitbucket can connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The Manage Jenkins » Configure Jenkins › Bitbucket Endpoints allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • mode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                There are two available modes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Disable hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure Jenkins › Bitbucket Endpoints
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • $class: 'com.cloudogu.scmmanager.scm.BranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'com.cloudogu.scmmanager.scm.TagDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • dagshubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.ForkPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'io.jenkins.plugins.dagshubbranchsource.traits.OriginPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • buildOnPullHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If checked, then the build will run on the commit at the tip of the pull request head, instead of first trying to merge it into the target branch and then running the build on the merged commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • dagshubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitLabBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Only branches that are not also filed as MRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If you are discovering origin merge requests, it may not make sense to discover the same changes both as a merge request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Only branches that are also filed as MRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a merge request against this text.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Ignores whether the branch is also filed as a merge request and instead discovers all branches on the origin project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • branchesAlwaysIncludedRegex : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Regular expression of branches that should always be included regardless of whether a merge request exists or not for those branches.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitLabSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      By default the discovered branches / merge requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitLabTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • headRegexFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • headWildcardFilter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Space-separated list of name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Space-separated list of name patterns to ignore even if matched by the includes list. For example: release alpha-* beta-*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NOTE: this filter will be applied to all branch like things, including change requests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • headRegexFilterWithPR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • regex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              A Java regular expression to restrict the names. Names that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • tagRegex : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              A Java regular expression to restrict the names. Names for tags that do not match the supplied regular expression will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • headWildcardFilterWithPR
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • includes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Space-separated list of branch name patterns to consider. You may use * as a wildcard; for example: master release*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • excludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Branch name patterns to ignore even if matched by the includes list. For example: release
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • tagIncludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Space-separated list of tag name patterns to consider. You may use * as a wildcard; for example: *-1.* to build only 1.0 tags from the maven release plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • tagExcludes : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Tag name patterns to ignore even if matched by the tag includes list. For example: *-0.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • giteaBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              If you are discovering origin pull requests, it may not make sense to discover the same changes both as a pull request and as a branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This option exists to preserve legacy behaviour when upgrading from older versions of the plugin. NOTE: If you have an actual use case for this option please file a pull request against this text.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Only branches that are also filed as PRs or main
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover branches that are also files as PRs (have open PRs) or that are the master / main branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • giteaForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Contributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of contributors to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on a Gitea instance that allows signup.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitLabTrustMembers
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • bitbucketTrustTeam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • bitbucketTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitLabTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitLabTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitLabTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • giteaTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • giteaTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • giteaTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • giteaPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • giteaSSHCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • giteaTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • giteaWebhookRegistration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Overrides the defaults for webhook management.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Webhooks are used to inform Jenkins about changes to repositories. There are two ways webhooks can be configured:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Manual webhook configuration requires the user to configure Gitea with the Jenkins URL in order to ensure that Gitea will send the events to Jenkins after every change.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Automatic webhook configuration requires that Jenkins has credentials with sufficient permission to configure webhooks and also that Jenkins knows the URL that Gitea can connect to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The Manage Jenkins » Configure System › Gitea Server allows defining the list of servers. Each server can be associated with credentials. If credentials are defined then the default behaviour is to use those credentials to automatically manage the webhooks of all repositories that Jenkins is interested in. If no credentials are defined then the default behaviour is to require the user to manually configure webhooks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • mode : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            There are two available modes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Disable hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Disables hook management irrespective of the global defaults.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Use item credentials for hook management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enabled hook management but uses the selected credentials to manage the hooks rather than those defined in Manage Jenkins » Configure System › Gitea Server
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubBranchDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers branches on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Determines which branches are discovered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Exclude branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If you are discovering origin pull requests, you may not want to also build the source branches for those pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Only branches that are also filed as PRs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Similar to discovering origin pull requests, but discovers the branch rather than the pull request. This means env.GIT_BRANCH will be set to the branch name rather than PR-#. Also, status notifications for these builds will only be applied to the commit and not to the pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            All branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Ignores whether the branch is also filed as a pull request and instead discovers all branches on the origin repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • gitHubForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discovers pull requests where the origin repository is a fork of the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            One of the great powers of pull requests is that anyone with read access to a repository can fork it, commit some changes to their fork and then create a pull request against the original repository with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox pull requests in order to mitigate against malicious pull requests. In order to protect against a malicious pull request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for pull requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Pull requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin repository and not from the pull request branch on the fork repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Collaborators
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Pull requests from collaborators to the origin repository will be treated as trusted, all other pull requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the repository does not have permission to query the list of collaborators to the origin repository then only the origin account will be treated as trusted - i.e. this will fall back to Nobody. NOTE: all collaborators are trusted, even if they are only members of a team with read permission.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            All pull requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public repository hosted on GitHub.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            From users with Admin or Write permission
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Pull requests forks will be treated as trusted if and only if the fork owner has either Admin or Write permissions on the origin repository. This is the recommended policy. Note that this strategy requires the Review a user's permission level API, as a result on GitHub Enterprise Server versions before 2.12 this is the same as trusting Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • gitHubTrustContributors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHubTrustEveryone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubTrustNobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitHubTrustPermissions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubPullRequestDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers pull requests where the origin repository is the same as the target repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines how pull requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Merging the pull request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the result of merging with the current revision of the target branch. Note that pushes to the target branch will result in new pull request builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The current pull request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request once with the discovered revision corresponding to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Both the current pull request revision and the pull request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discover each pull request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the pull request head revision without merging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubSshCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  By default the discovered branches / pull requests will all use the same username / password credentials that were used for discovery when checking out sources. This means that the checkout will be using the https:// protocol for the Git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This behaviour allows you to select the SSH private key to be used for checking out sources, which will consequently force the checkout to use the ssh:// protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Credentials used to check out sources. Must be a SSH key based credential.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubTagDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers tags on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gitHub
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • handlers (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • events (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • checks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • commitMessagePattern
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If set, the plugin will only build revisions commited with messages that match the pattern. If 'skip' is selected, any revisions with matching messages will be ignored.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This can be used to exclude commits done by the build itself from triggering another build, assuming the build server commits the change with a distinct message.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • exclude : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • matchCriteria : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Inclusion/Exclusion uses pattern matching

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              .*\[maven-release-plugin\].*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The example above illustrates that if only revisions with "[maven-release-plugin]" message in first comment line have been committed to the SCM a build will not occur.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              You can create more complex patterns using embedded flag expressions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (?s).*FOO.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This example will search FOO message in all comment lines.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • branchCreated
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • deleted
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • hashChanged
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • restriction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • exclude : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • matchAsPattern : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • matchCriteriaStr : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • pullRequests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • events (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • close
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Triggers when a pull request is closed. Works only when pull request was opened and closed between persistence-based trigger runs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • commentPattern
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Triggers when a comment matching the pattern is posted in a pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For example Test ([A-Za-z0-9 ,!]+) tags please.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • comment : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • commitChanged
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Triggers when a previously built pull request's hash has changed from the previous state (i.e., a new commit is pushed, or force-pushed).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • description
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If given, don't build a pull request if its description contains the given string.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • skipMsg : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • labelsAdded
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Triggers run when label is added to pull request. Set of labels is considered added only when at least one label of set was newly added (was not saved in local PR previously) AND every label of set exists on remote PR now.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • label
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Help page for GitHubPRLabel class. Not used anywhere?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • labels : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Every new label on new line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • labelsExist
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Triggers when all the given labels are on a pull request, or blocks triggering if all the given labels are on a pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NOTE: This can cause infinite triggers of pull requests when the skip option isn't selected, so be careful.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • label
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Help page for GitHubPRLabel class. Not used anywhere?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • labels : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Every new label on new line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • skip : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • labelsNotExist
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Triggers or skips triggering when all the given labels are missing from a pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NOTE: This can cause infinite triggers of pull requests when the skip option isn't selected, so be careful.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • label
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Help page for GitHubPRLabel class. Not used anywhere?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • labels : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Every new label on new line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • skip : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • labelsPatternExists
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Triggers when a label on a pull request matches the given pattern, or blocks triggering when a label matches, as configured.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NOTE: This can cause infinite triggers of pull requests when the skip option isn't selected, so be careful.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • label
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Help page for GitHubPRLabel class. Not used anywhere?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • labels : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Every new label on new line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • skip : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • labelsRemoved
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Triggers a build when the label or labels specified are removed from a pull request. Note that with multiple labels, all of the labels must be removed to cause the trigger to fire.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • label
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Help page for GitHubPRLabel class. Not used anywhere?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • labels : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Every new label on new line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • nonMergeable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • skip : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • number : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PR number to run additional checks against
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • match : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Defines whether the pull request number in the trigger event must match to the above PR number. If not, then logic is not applied and the event wouldn't influence on the trigger result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • skip : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Defines whether a matching or non matching pull request number in the trigger event, depending on the above "Match number" flag, skips building instead of triggering a build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Open
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Triggers a build of a pull request when the pull request is opened or reopened.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • tags
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • events (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • created
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • restrictions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • exclude : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • matchAsPattern : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • matchCriteriaStr : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • id : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • projectUrlStr : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • repoProvider (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • gitHubPlugin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • cacheConnection : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • manageHooks : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • repoPermission (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Values: ADMIN, PUSH, PULL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • scmFactory (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • asIsGITScm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitSCM
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nested Object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The git plugin provides fundamental git operations for Jenkins projects. It can poll, fetch, checkout, and merge contents of git repositories.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The git plugin provides an SCM implementation to be used with the Pipeline SCM checkout step. The Pipeline Syntax Snippet Generator guides the user to select git plugin checkout options and provides online help for each of the options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Use the Pipeline Snippet Generator to generate a sample pipeline script for the checkout step. Examples of the checkout step include:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      See the argument descriptions for more details.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The checkout step provides access to all the Pipeline capabilities provided by the git plugin:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      checkout scmGit(userRemoteConfigs: [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [ url: 'https://github.com/jenkinsci/git-plugin' ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NOTE: The checkout step is the preferred SCM checkout method. For simpler cases that do not require all the capabilities of the git plugin, the git step can also be used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Use the Pipeline Snippet Generator to generate a sample pipeline script for the checkout step.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The checkout step can be used in many cases where the git step cannot be used. Refer to the git plugin documentation for detailed descriptions of options available to the checkout step. For example, the checkout step supports:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • SHA-1 checkout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Tag checkout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Submodule checkout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Sparse checkout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Large file checkout (LFS)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Reference repositories
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Branch merges
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Repository tagging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Custom refspecs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Timeout configuration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Changelog calculation against a non-default reference
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Stale branch pruning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Example: Checkout step with defaults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Checkout from the git plugin source repository using https protocol, no credentials, and the master branch.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The Pipeline Snippet Generator generates this example:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      checkout scmGit(userRemoteConfigs: [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [ url: 'https://github.com/jenkinsci/git-plugin' ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Example: Checkout step with https and a specific branch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Checkout from the Jenkins source repository using https protocol, no credentials, and a specific branch (stable-2.289).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The Pipeline Snippet Generator generates this example:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      checkout scmGit(branches: [[name: 'stable-2.289']],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      userRemoteConfigs: [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [ url: 'https://github.com/jenkinsci/jenkins.git' ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Example: Checkout step with ssh and a private key credential

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Checkout from the git client plugin source repository using ssh protocol, private key credentials, and the master branch. The credential must be a private key credential if the remote git repository is accessed with the ssh protocol. The credential must be a username / password credential if the remote git repository is accessed with http or https protocol.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The Pipeline Snippet Generator generates this example:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      checkout changelog: false,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               scm: scmGit(userRemoteConfigs: [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               [ credentialsId: 'my-private-key-credential-id',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 url: 'git@github.com:jenkinsci/git-client-plugin.git' ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Example: Checkout step with https and changelog disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Checkout from the Jenkins source repository using https protocol, no credentials, the master branch, and changelog calculation disabled. If changelog is false, then the changelog will not be computed for this job. If changelog is true or is not set, then the changelog will be computed. See the workflow scm step documentation for more changelog details.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The Pipeline Snippet Generator generates this example:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      checkout changelog: false,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               scmGit(userRemoteConfigs: [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [ url: 'https://github.com/jenkinsci/credentials-plugin' ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Example: Checkout step with git protocol and polling disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Checkout from the command line git repository using git protocol, no credentials, the master branch, and no polling for changes. If poll is false, then the remote repository will not be polled for changes. If poll is true or is not set, then the remote repository will be polled for changes. See the workflow scm step documentation for more polling details.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The Pipeline Snippet Generator generates this example:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      checkout poll: false,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               scmGit(userRemoteConfigs: [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [ url: 'git://git.kernel.org/pub/scm/git/git.git ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Argument Descriptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • userRemoteConfigs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the repository to track. This can be a URL or a local file path. Note that for super-projects (repositories with submodules), only a local file path or a complete URL is valid. The following are examples of valid git URLs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ssh://git@github.com/github/git.git
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • git@github.com:github/git.git (short notation for ssh protocol)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ssh://user@other.host.com/~/repos/R.git (to access the repos/R.git repository in the user's home directory)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • https://github.com/github/git.git

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If the repository is a super-project, the location from which to clone submodules is dependent on whether the repository is bare or non-bare (i.e. has a working directory).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • If the super-project is bare, the location of the submodules will be taken from .gitmodules.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • If the super-project is not bare, it is assumed that the repository has each of its submodules cloned and checked out appropriately. Thus, the submodules will be taken directly from a path like ${SUPER_PROJECT_URL}/${SUBMODULE}, rather than relying on information from .gitmodules.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      For a local URL/path to a super-project, git rev-parse --is-bare-repository is used to detect whether the super-project is bare or not.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      For a remote URL to a super-project, the ending of the URL determines whether a bare or non-bare repository is assumed:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • If the remote URL ends with .git, a non-bare repository is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • If the remote URL does NOT end with .git, a bare repository is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the URL or path of the git repository. This uses the same syntax as your git clone command.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • name : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ID of the repository, such as origin, to uniquely identify this repository among other remote repositories. This is the same "name" that you use in your git remote command. If left empty, Jenkins will generate unique names for you.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You normally want to specify this when you have multiple remote repositories.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • refspec : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A refspec controls the remote refs to be retrieved and how they map to local refs. If left blank, it will default to the normal behaviour of git fetch, which retrieves all the branch heads as remotes/REPOSITORYNAME/BRANCHNAME. This default behaviour is OK for most cases.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        In other words, the default refspec is "+refs/heads/*:refs/remotes/REPOSITORYNAME/*" where REPOSITORYNAME is the value you specify in the above "name of repository" textbox.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        When do you want to modify this value? A good example is when you want to just retrieve one branch. For example, +refs/heads/master:refs/remotes/origin/master would only retrieve the master branch and nothing else.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The plugin uses a default refspec for its initial fetch, unless the "Advanced Clone Option" is set to honor refspec. This keeps compatibility with previous behavior, and allows the job definition to decide if the refspec should be honored on initial clone.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Multiple refspecs can be entered by separating them with a space character. +refs/heads/master:refs/remotes/origin/master +refs/heads/develop:refs/remotes/origin/develop retrieves the master branch and the develop branch and nothing else.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        See the refspec definition in Git user manual for more details.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • credentialsId : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Credential used to check out sources.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      List of branches to build. Jenkins jobs are most effective when each job builds only a single branch. When a single job builds multiple branches, the changelog comparisons between branches often show no changes or incorrect changes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • name : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the branches if you'd like to track a specific branch in a repository. If left blank, all branches will be examined for changes and built.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The safest way is to use the refs/heads/<branchName> syntax. This way the expected branch is unambiguous.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If your branch name has a / in it make sure to use the full reference above. When not presented with a full path the plugin will only use the part of the string right of the last slash. Meaning foo/bar will actually match bar.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If you use a wildcard branch specifier, with a slash (e.g. release/), you'll need to specify the origin repository in the branch names to make sure changes are picked up. So e.g. origin/release/

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Possible options:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • <branchName>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Tracks/checks out the specified branch. If ambiguous the first result is taken, which is not necessarily the expected one. Better use refs/heads/<branchName>.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          E.g. master, feature1, ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • refs/heads/<branchName>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Tracks/checks out the specified branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          E.g. refs/heads/master, refs/heads/feature1/master, ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • <remoteRepoName>/<branchName>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Tracks/checks out the specified branch. If ambiguous the first result is taken, which is not necessarily the expected one.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Better use refs/heads/<branchName>.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          E.g. origin/master
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • remotes/<remoteRepoName>/<branchName>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Tracks/checks out the specified branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          E.g. remotes/origin/master
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • refs/remotes/<remoteRepoName>/<branchName>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Tracks/checks out the specified branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          E.g. refs/remotes/origin/master
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • <tagName>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This does not work since the tag will not be recognized as tag.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Use refs/tags/<tagName> instead.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          E.g. git-2.3.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • refs/tags/<tagName>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Tracks/checks out the specified tag.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          E.g. refs/tags/git-2.3.0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • <commitId>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Checks out the specified commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          E.g. 5062ac843f2b947733e6a3b105977056821bd352, 5062ac84, ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • ${ENV_VARIABLE}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          It is also possible to use environment variables. In this case the variables are evaluated and the result is used as described above.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          E.g. ${TREEISH}, refs/tags/${TAGNAME}, ...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • <Wildcards>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The syntax is of the form: REPOSITORYNAME/BRANCH. In addition, BRANCH is recognized as a shorthand of */BRANCH, '*' is recognized as a wildcard, and '**' is recognized as wildcard that includes the separator '/'. Therefore, origin/branches* would match origin/branches-foo but not origin/branches/foo, while origin/branches** would match both origin/branches-foo and origin/branches/foo.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • :<regular expression>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The syntax is of the form: :regexp. Regular expression syntax in branches to build will only build those branches whose names match the regular expression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Examples:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • :^(?!(origin/prefix)).*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • matches: origin or origin/master or origin/feature
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • does not match: origin/prefix or origin/prefix_123 or origin/prefix-abc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • :origin/release-\d{8}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • matches: origin/release-20150101
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • does not match: origin/release-2015010 or origin/release-201501011 or origin/release-20150101-something
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • :^(?!origin/master$|origin/develop$).*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • matches: origin/branch1 or origin/branch-2 or origin/master123 or origin/develop-123
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • does not match: origin/master or origin/develop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Defines the repository browser that displays changes detected by the git plugin.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • assembla
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • cgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • fisheye
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitblit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitLab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • kiln
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • phabricator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repo : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • redmine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • jbSpace
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Provide the absolute URL to your repository in JetBrains SpaceCode in the following format: https://<your SpaceCode instance>/p/<project key>/repositories/<repository name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • viewgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitTool : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Name of the git tool to be used for this job. Git tool names are defined in "Global Tool Configuration".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • extensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Extensions add new behavior or modify existing plugin behavior for different uses. Extensions help users more precisely tune plugin behavior to meet their needs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Extensions include:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Clone extensions modify the git operations that retrieve remote changes into the agent workspace. The extensions can adjust the amount of history retrieved, how long the retrieval is allowed to run, and other retrieval details.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Checkout extensions modify the git operations that place files in the workspace from the git repository on the agent. The extensions can adjust the maximum duration of the checkout operation, the use and behavior of git submodules, the location of the workspace on the disc, and more.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Changelog extensions adapt the source code difference calculations for different cases.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Tagging extensions allow the plugin to apply tags in the current workspace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Build initiation extensions control the conditions that start a build. They can ignore notifications of a change or force a deeper evaluation of the commits when polling.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Merge extensions can optionally merge changes from other branches into the current branch of the agent workspace. They control the source branch for the merge and the options applied to the merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • authorInChangelog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The default behavior is to use the Git commit's "Committer" value in Jenkins' build changesets. If this option is selected, the Git commit's "Author" value would be used instead.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'BuildChooserSetting'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            When you are interested in using a job to build multiple heads (most typically multiple branches), you can choose how Jenkins choose what branches to build in what order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This extension point in Jenkins is used by many other plugins to control the job to build specific commits. When you activate those plugins, you may see them installing a custom strategy here.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • buildChooser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'AlternativeBuildChooser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'AncestryBuildChooser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • maximumAgeInDays : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • ancestorCommitSha1 : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'DefaultBuildChooser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'DeflakeGitBuildChooser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'GerritTriggerBuildChooser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'InverseBuildChooser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • buildSingleRevisionOnly
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Disable scheduling for multiple candidate revisions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If we have 3 branches:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ----A--.---.--- B
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               \-----C
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      jenkins would try to build (B) and (C).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This behaviour disables this and only builds one of them.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      It is helpful to reduce the load of the Jenkins infrastructure when the SCM system like Bitbucket or GitHub should decide what commits to build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • changelogToBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This method calculates the changelog against the specified branch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • compareRemote : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Name of the repository, such as origin, that contains the branch you specify below.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • compareTarget : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The name of the branch within the named repository to compare against.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • checkoutOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify a timeout (in minutes) for checkout.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • cleanBeforeCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Clean up the workspace before every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • cleanAfterCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Clean up the workspace after every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • cloneOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • shallow : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • noTags : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Deselect this to perform a clone without tags, saving time and disk space when you just want to access what is specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • reference : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify a timeout (in minutes) for clone and fetch operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • honorRefspec : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Perform initial clone using the refspec defined for the repository. This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'CodeCommitURLHelper'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • credentialId : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          OPTIONAL: Select the credentials to use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If not specified, defaults to the DefaultAWSCredentialsProviderChain behaviour - *FROM THE JENKINS INSTANCE*

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          In the latter case, usage of IAM Role Profiles seems not to work, thus relying on environment variables / system properties or the ~/.aws/credentials file, thus not recommended.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • repositoryName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'DisableRemotePoll'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Git plugin uses git ls-remote polling mechanism by default when configured with a single branch (no wildcards!). This compare the latest built commit SHA with the remote branch without cloning a local copy of the repo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If you don't want to / can't use this.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If this option is selected, polling will require a workspace and might trigger unwanted builds (see JENKINS-10131).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • $class: 'ExcludeFromChangeSet'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'ExcludeFromPoll'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • lfs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enable git large file support for the workspace by pulling large files after the checkout completes. Requires that the controller and each agent performing an LFS checkout have installed `git lfs`.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'GitSCMChecksExtension'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • verboseConsoleLog : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If this option is checked, verbose log will be output to build console; the verbose log is useful for debugging the publisher creation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'GitSCMStatusChecksExtension'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • name : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • skip : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • skipProgressUpdates : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • suppressLogs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • unstableBuildNeutral : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'GitTagMessageExtension'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If the revision checked out has a git tag associated with it, the tag name will be exported during the build as GIT_TAG_NAME.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If a message was specified when creating the tag, then that message will be exported during the build as the GIT_TAG_MESSAGE environment variable.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If no tag message was specified, the commit message will be used.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If you ticked the Use most recent tag option, and the revision checked out has no git tag associated with it, the parent commits will be searched for a git tag, and the rules stated above will apply to the first parent commit with a git tag.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If the revision has more than one tag associated with it, only the most recent tag will be taken into account, unless the refspec contains "refs/tags/" — i.e. builds are only triggered when certain tag names or patterns are matched — in which case the exact tag name that triggered the build will be used, even if it's not the most recent tag for this commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For this reason, if you're not using a tag-specific refspec but you are using the "Create a tag for every build" behaviour, you should make sure that the build-tagging behaviour is configured to run after this "export git tag message" behaviour.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Tag and commit messages which span multiple lines are no problem, though only the first 10000 lines of a tag's message will be exported.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • useMostRecentTag : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'IgnoreNotifyCommit'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If checked, this repository will be ignored when the notifyCommit-URL is accessed regardless of if the repository matches or not.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • localBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If given, checkout the revision to build as HEAD on this branch.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If selected, and its value is an empty string or "**", then the branch name is computed from the remote branch without the origin. In that case, a remote branch origin/master will be checked out to a local branch named master, and a remote branch origin/develop/new-feature will be checked out to a local branch named develop/newfeature.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Please note that this has not been tested with submodules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • localBranch : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'MessageExclusion'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • excludedMessage : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If set, and Jenkins is set to poll for changes, Jenkins will ignore any revisions committed with message matched to Pattern when determining if a build needs to be triggered. This can be used to exclude commits done by the build itself from triggering another build, assuming the build server commits the change with a distinct message.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Exclusion uses Pattern matching

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    .*\[maven-release-plugin\].*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The example above illustrates that if only revisions with "[maven-release-plugin]" message in first comment line have been committed to the SCM a build will not occur.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can create more complex patterns using embedded flag expressions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (?s).*FOO.*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This example will search FOO message in all comment lines.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'PathRestriction'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  If set, and Jenkins is set to poll for changes, Jenkins will pay attention to included and/or excluded files and/or folders when determining if a build needs to be triggered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Using this behaviour will preclude the faster git ls-remote polling mechanism, forcing polling to require a workspace thus sometimes triggering unwanted builds, as if you had selected the Force polling using workspace extension as well.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • includedRegions : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Each inclusion uses java regular expression pattern matching, and must be separated by a new line. An empty list implies that everything is included.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        myapp/src/main/web/.*\.html
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        myapp/src/main/web/.*\.jpeg
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        myapp/src/main/web/.*\.gif
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The example above illustrates that a build will only occur, if html/jpeg/gif files have been committed to the SCM. Exclusions take precedence over inclusions, if there is an overlap between included and excluded regions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • excludedRegions : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Each exclusion uses java regular expression pattern matching, and must be separated by a new line.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        myapp/src/main/web/.*\.html
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        myapp/src/main/web/.*\.jpeg
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        myapp/src/main/web/.*\.gif
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The example above illustrates that if only html/jpeg/gif files have been committed to the SCM a build will not occur.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • perBuildTag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Create a tag in the workspace for every build to unambiguously mark the commit that was built. You can combine this with Git publisher to push the tags to the remote repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'PreBuildMerge'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    These options allow you to perform a merge to a particular branch before building. For example, you could specify an integration branch to be built, and to merge to master. In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful. It then may push the merge back to the remote repository if the Git Push post-build action is selected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • mergeTarget : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The name of the branch within the named repository to merge to, such as master.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • fastForwardMode (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Merge fast-forward mode selection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The default, --ff, gracefully falls back to a merge commit when required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For more information, see the Git Merge Documentation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Values: FF, FF_ONLY, NO_FF
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • mergeRemote : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Name of the repository, such as origin, that contains the branch you specify below. If left blank, it'll default to the name of the first repository configured above.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • mergeStrategy (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Merge strategy selection. This feature is not fully implemented in JGIT.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Values: DEFAULT, RESOLVE, RECURSIVE, OCTOPUS, OURS, SUBTREE, RECURSIVE_THEIRS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • pretestedIntegration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • gitIntegrationStrategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • accumulated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Accumulated Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This strategy merges your commits with the --no-ff switch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ffonly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fast Forward only (--ff-only) Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This strategy fast-forward only using the --ff-only switch - or fails
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • shortCommitMessage : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • squash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Squashed Commit Strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This strategy squashes all your commit on a given branch with the --squash option
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • integrationBranch : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        What to specify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The branch name must match your integration branch name. No trailing slash.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Merge is performed the following way

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Squash commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git merge --squash <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git commit -C <Branch matched by git>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Accumulated commit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git checkout -B <Branch name> <Repository name>/<Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git merge -m <commitMsg> <Branch matched by git> --no-ff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        When changes are pushed to the integration branch?

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Changes are only ever pushed when the build results is SUCCESS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git push <Repository name> <Branch name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        What to specify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The repository name. In git the repository is always the name of the remote. So if you have specified a repository name in your Git configuration. You need to specify the exact same name here, otherwise no integration will be performed. We do the merge based on this.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        No trailing slash on repository name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Remember to specify this when working with NAMED repositories in Git

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • pruneStaleBranch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Run "git remote prune" for each remote, to prune obsolete local branches.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • pruneTags
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • pruneTags : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'RelativeTargetDirectory'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • relativeTargetDir : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify a local directory (relative to the workspace root) where the Git repository will be checked out. If left empty, the workspace root itself will be used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This extension should not be used in Jenkins Pipeline (either declarative or scripted). Jenkins Pipeline already provides standard techniques for checkout to a subdirectory. Use ws and dir in Jenkins Pipeline rather than this extension.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'ScmName'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Unique name for this SCM. Needed when using Git within the Multi SCM plugin.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • name : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'SparseCheckoutPaths'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the paths that you'd like to sparse checkout. This may be used for saving space (Think about a reference repository). Be sure to use a recent version of Git, at least above 1.7.10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • sparseCheckoutPaths
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • path : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • submodule
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • disableSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          By disabling support for submodules you can still keep using basic git plugin functionality and just have Jenkins to ignore submodules completely as if they didn't exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • parentCredentials : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Use credentials from the default remote of the parent project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • recursiveSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Retrieve all submodules recursively (uses '--recursive' option which requires git>=1.6.5)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • reference : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          To prepare a reference folder with multiple subprojects, create a bare git repository and add all the remote urls then perform a fetch:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git init --bare
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git remote add SubProject1 https://gitrepo.com/subproject1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git remote add SubProject2 https://gitrepo.com/subproject2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git fetch --all
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • shallow : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • threads : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify the number of threads that will be used to update submodules.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If unspecified, the command line git default thread count is used.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • timeout : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify a timeout (in minutes) for submodules operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • trackingSubmodules : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Retrieve the tip of the configured branch in .gitmodules (Uses '--remote' option which requires git>=1.8.2)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'UserExclusion'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • excludedUsers : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If set, and Jenkins is set to poll for changes, Jenkins will ignore any revisions committed by users in this list when determining if a build needs to be triggered. This can be used to exclude commits done by the build itself from triggering another build, assuming the build server commits the change with a distinct SCM user.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Using this behaviour will preclude the faster git ls-remote polling mechanism, forcing polling to require a workspace thus sometimes triggering unwanted builds, as if you had selected the Force polling using workspace extension as well.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Each exclusion uses exact string comparison and must be separated by a new line. User names are only excluded if they exactly match one of the names in this list.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          auto_build_user
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The example above illustrates that if only revisions by "auto_build_user" have been committed to the SCM a build will not occur.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'UserIdentity'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • name : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If given, "GIT_COMMITTER_NAME=[this]" and "GIT_AUTHOR_NAME=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • email : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If given, "GIT_COMMITTER_EMAIL=[this]" and "GIT_AUTHOR_EMAIL=[this]" are set for builds. This overrides whatever is in the global settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'WipeWorkspace'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Delete the contents of the workspace before building, ensuring a fully fresh workspace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • doGenerateSubmoduleConfigurations : boolean (optional)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Removed facility that was intended to test combinations of git submodule versions. Removed in git plugin 4.6.0. Ignores the user provided value and always uses false as its value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • submoduleCfg (optional)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Removed facility that was intended to test combinations of git submodule versions. Removed in git plugin 4.6.0. Ignores the user provided value(s) and always uses empty values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Array / List of Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • submoduleName : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Removed in git plugin 4.6.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • branches : Array / List of String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Removed in git plugin 4.6.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • noGITScm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoOwner : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the name of the GitHub Organization or GitHub User Account.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repository : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The repository to scan.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repositoryUrl : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTPS URL of the GitHub Organization / User Account and repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GitHub examples:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • https://github.com/jenkinsci/github-branch-source-plugin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • https://github.com/jenkinsci/github-branch-source-plugin.git

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GitHub Enterprise examples:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • https://myccompany.github.com/jenkinsci/github-branch-source-plugin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • https://myccompany.github.com/jenkinsci/github-branch-source-plugin.git

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • configuredByUrl : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • apiUri : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The server to connect to. The list of servers is configured in the Manage Jenkins » Configure System » GitHub Enterprise Servers screen.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • buildForkPRHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • buildForkPRMerge : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • buildOriginBranch : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • buildOriginBranchWithPR : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • buildOriginPRHead : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • buildOriginPRMerge : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • credentialsId : String (optional)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Credentials used to scan branches and pull requests, check out sources and mark commit statuses.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Note that only "username with password" credentials are supported. Existing credentials of other kinds will be filtered out. This is because Jenkins uses the GitHub API, which does not support other ways of authentication.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If none is given, only the public repositories will be scanned, and commit status will not be set on GitHub.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If your organization contains private repositories, then you need to specify a credential from a user who has access to those repositories. This is done by creating a "username with password" credential where the password is GitHub personal access tokens. The necessary scope is "repo".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • excludes : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • id : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • includes : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • traits (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The behaviours control what is discovered from the GitHub repository. The behaviours are grouped into a number of categories:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Within repository
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      These behaviours determine what gets discovered. If you do not configure at least one discovery behaviour then nothing will be found!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      General
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      These behaviours affect the configuration of each discovered branch / pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Array / List of Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'ApprovedPullRequestTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Sets if approvals are required before building pull requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          No approval necessary.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          No check of approvals will be performed before building.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Any approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Before building the pull request must be approved. This may be performed by the author or someone else.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Non-author approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Before building the pull request must be approved and that approval cannot be performed by the author of the pull request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Author and Non-author approval required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Before building the pull request must be approved by the author and a non-author.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • authorInChangelog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketAgedRefsTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Defines the number of days to accept an unmodified git ref as candidate for being built (supposing it contains a Jenkinsfile). In a practical effect it is a ripoff from the Orphaned Item Strategy but on indexing time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • retentionDays : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • bitbucketBranchCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Branches whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'BitbucketBranchDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discovers branches in the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketBuildStatusNotifications
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Configure the Bitbucket notifications.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • disableNotificationForNotBuildJobs : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • sendSuccessNotificationForUnstableBuild : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • bitbucketCommitSkipTrait
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Pull requests whose last commit's message contains (case insensitive) the pattern "[ci skip]" or "[skip ci]" will be ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • $class: 'BitbucketGitBrowserSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • assembla
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • cgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • fisheye
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitblit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitLab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gitiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • gogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • kiln
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • phabricator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repo : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the repository name in phabricator (such as the foo part of phabricator.example.com/diffusion/foo/browse).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • redmine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://redmine.example.com/PATH/projects/PROJECT/repository).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • rhodeCode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this repository's RhodeCode page (such as https://rhodecode.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'ScmManagerGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the root URL serving this repository (such as https://scm-manager.org/scm/repo/namespace/name).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • jbSpace
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Provide the absolute URL to your repository in JetBrains SpaceCode in the following format: https://<your SpaceCode instance>/p/<project key>/repositories/<repository name>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'Stash'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTP URL for this repository's Stash page (such as https://stash.example.com/projects/PROJECT/repos/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • teamFoundation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Either the name of the remote whose URL should be used, or the URL of this module in TFS (such as https://tfs.example.com/tfs/PROJECT/_git/REPO/). If empty (default), the URL of the "origin" repository is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If TFS is also used as the repository server, this can usually be left blank.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'TracGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'TuleapBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Specify the HTTPS URL for the Tuleap Git repository so that links to changes can be automatically generated by Jenkins.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repositoryUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The URL is the web URL of the Tuleap Git repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • viewgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the root URL serving this repository (such as https://git.example.com/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify the name of the project in ViewGit (e.g. scripts, scuttle etc. from https://code.fealdia.org/viewgit/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'BitbucketJiraValidatorTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enforces a pull request to be filled with a title containing a single and unresolved Jira ticket, formatted as defined at the global config (defaulting matching as JENKINS-1234).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • jiraServerIdx : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • $class: 'BitbucketPullRequestDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Discovers open pull requests in the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • buildStatusNameCustomPart
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Customize the pipeline status name used by Jenkins
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • buildStatusNameCustomPart : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enter a string to customize the status/context name for status updates published to GitLab. For a branch build the default name would be 'jenkinsci/branch'. With the buildStatusNameCustomPart 'custom' the name would be 'jenkinsci/custom/branch'. This allows to have multiple GitLab-Branch-Sources for the same GitLab-project configured.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • buildStatusNameOverwrite : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Overwrites the build status name including the jenkinsci default part.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Instead of 'jenkinsci/custom/branch' just 'custom/branch'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ignoreTypeInStatusName : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'ChangeDiscoveryTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • queryString : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Provide an additional query string to search for open changes. The status:open is implicitly added and does not need to be specified. See Gerrit search operators documentation for a detailed list of the supported search operators.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Examples:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • -is:wip
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        does not include work-in-progress changes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • is:private
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        includes private changes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • checkoutOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Specify a timeout (in minutes) for checkout.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • cleanAfterCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Clean up the workspace after every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • cleanBeforeCheckout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Clean up the workspace before every checkout by deleting all untracked files and directories, including those which are specified in .gitignore. It also resets all tracked files to their versioned state. This ensures that the workspace is in the same state as if you cloned and checked out in a brand-new empty directory, and ensures that your build is not affected by the files generated by the previous build.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • deleteUntrackedNestedRepositories : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Deletes untracked submodules and any other subdirectories which contain .git directories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • $class: 'CleanMercurialSCMSourceTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When this behaviour is present, each build will wipe any local modifications or untracked files in the repository checkout. This is often a convenient way to ensure that a build is not using any artifacts from earlier builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • cloneOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • extension
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nested Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • shallow : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Perform shallow clone, so that git will not download the history of the project, saving time and disk space when you just want to access the latest version of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • noTags : boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Deselect this to perform a clone without tags, saving time and disk space when you just want to access what is specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • reference : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify a folder containing a repository that will be used by Git as a reference during clone operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This option will be ignored if the folder is not available on the controller or agent where the clone is being executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • timeout : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Specify a timeout (in minutes) for clone and fetch operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This option overrides the default timeout of 10 minutes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          You can change the global git timeout via the property org.jenkinsci.plugins.gitclient.Git.timeOut (see JENKINS-11286). Note that property should be set on both controller and agent to have effect (see JENKINS-22547).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • depth : int (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Set shallow clone depth, so that git will only download recent history of the project, saving time and disk space when you just want to access the latest commits of a repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • honorRefspec : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Perform initial clone using the refspec defined for the repository. This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • $class: 'DisableStatusUpdateTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Disables notifications (commit status updates) to GitHub for builds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • discoverOtherRefs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers other specified refs on the repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • ref : String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The pattern under /refs on the remote repository to discover, can contain a wildcard.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Example: test/*/merged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • nameMapping : String (optional)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Mapping for how the ref can be named in for example the @Library.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Example: test-@{1}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Where @{1} replaces the first wildcard in the ref when discovered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          By default it will be "namespace_before_wildcard-@{1}". E.g. if ref is "test/*/merged" the default mapping would be "test-@{1}".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • $class: 'FilterChecksTrait'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • queryOperator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Values: ID, SCHEME
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • queryString : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Provide a query string to search for pending checks. Depending on which mode was chosen, this either should be a checker-scheme or the UUID of a specific checker.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gitLabForkDiscovery
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Discovers merge requests where the origin project is a fork of the target project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • strategyId : int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Determines how merge requests are discovered:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Merging the merge request with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each merge request once with the discovered revision corresponding to the result of merging with the current revision of the target branch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The current merge request revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each merge request once with the discovered revision corresponding to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Both the current merge request revision and the merge request merged with the current target branch revision
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Discover each merge request twice. The first discovered revision corresponds to the result of merging with the current revision of the target branch in each scan. The second parallel discovered revision corresponds to the merge request head revision without merging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • trust

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          One of the great powers of merge requests is that anyone with read access to a project can fork it, commit some changes to their fork and then create a merge request against the original project with their changes. There are some files stored in source control that are important. For example, a Jenkinsfile may contain configuration details to sandbox merge requests in order to mitigate against malicious merge requests. In order to protect against a malicious merge request itself modifying the Jenkinsfile to remove the protections, you can define the trust policy for merge requests from forks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Other plugins can extend the available trust policies. The default policies are:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nobody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Merge requests from forks will all be treated as untrusted. This means that where Jenkins requires a trusted file (e.g. Jenkinsfile) the contents of that file will be retrieved from the target branch on the origin project and not from the merge request branch on the fork project.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Members
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Merge requests from collaborators to the origin project will be treated as trusted, all other merge requests from fork repositories will be treated as untrusted. Note that if credentials used by Jenkins for scanning the project does not have permission to query the list of contributors to the origin project then only the origin account will be treated as trusted - i.e. this will fall back to Nobody.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Trusted Members
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Merge requests forks will be treated as trusted if and only if the fork owner has either Developer or Maintainer or Owner Access Level in the origin project. This is the recommended policy.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Everyone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          All merge requests from forks will be treated as trusted. NOTE: this option can be dangerous if used on a public project hosted on a GitLab instance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Type: jenkins.scm.api.trait.SCMHeadAuthority<? super io.jenkins.plugins.gitlabbranchsource.GitLabSCMSourceRequest, ? extends jenkins.scm.api.mixin.ChangeRequestSCMHead2, ? extends jenkins.scm.api.SCMRevision>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • buildMRForksNotMirror : boolean (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Add discovery of merge requests where the origin project is a fork of a certain project, but the target project is not the original forked project. To be used in case one has a GitLab project which is a fork of another project from another team, in order to isolate artefacts and allow an MR flow. This means using MRs inside that fork from branches in the fork back to the fork's default branch. (Implements https://github.com/jenkinsci/gitlab-branch-source-plugin/issues/167)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • browser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nested Choice of Objects
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • assembla
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://www.assembla.com/code/PROJECT/git/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'BacklogGitRepositoryBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucketServer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the Bitbucket Server root URL for this repository (such as https://bitbucket:7990/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • bitbucket
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://bitbucket.org/OWNER/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • cgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://cgit.example.com:port/group/REPO/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • fisheye
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the URL of this repository in FishEye (such as https://fisheye.example.com/browse/project/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitblit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • projectName : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the name of the project in GitBlit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'GitBucketBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • url : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitLab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://gitlab.com/username/repository/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • version : String (optional)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the major and minor version of GitLab you use (such as 9.1). If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitLabBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specify the HTTP URL for this project's GitLab page so that links to changes can be automatically generated by Jenkins. The URL needs to include the owner and project. If the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • projectUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTP URL for this project's GitLab page. The URL needs to include the owner and project so, for example, if the GitLab server is https://gitLab.example.com then the URL for bob's skunkworks project might be https://gitLab.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://gitlist.example.com/repo/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitWeb
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://github.com/jenkinsci/jenkins.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'GiteaBrowser'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTP URL for this repository's Gitea page. The URL needs to include the owner and repository so, for example, if the Gitea server is https://gitea.example.com then the URL for bob's skunkworks project repository might be https://gitea.example.com/bob/skunkworks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the HTTP URL for this repository's GitHub page (such as https://github.com/jquery/jquery).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gitiles
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://gwt.googlesource.com/gwt/).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • $class: 'GitoriousWeb'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://gitorious.org/gitorious/mainline).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • gogs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://gogs.example.com/username/some-repo-url.git).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • kiln
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the root URL serving this repository (such as https://khanacademy.kilnhg.com/Code/Website/Group/webapp).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • phabricator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repoUrl : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specify the phabricator instance root URL (such as https://phabricator.example.com).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • repo : String
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Sp