module

type Apt struct {
	Params AptParams
	Result AptResult
}

type AptKey struct {
	Params AptKeyParams
	Result AptKeyResult
}

type AptKeyParams struct {

	// Data
	// The keyfile contents to add to the keyring.
	//
	// Default: <no value>
	// Required: false
	Data string `yaml:"data,omitempty" json:"data,omitempty" cty:"data"`

	// File
	// The path to a keyfile on the remote server to add to the keyring.
	//
	// Default: <no value>
	// Required: false
	File string `yaml:"file,omitempty" json:"file,omitempty" cty:"file"`

	// Id
	// The identifier of the key.
	// Including this allows check mode to correctly report the changed state.
	// If specifying a subkey's id be aware that apt-key does not understand how to remove keys via a subkey id.  Specify the primary key's id instead.
	// This parameter is required when C(state) is set to C(absent).
	//
	// Default: <no value>
	// Required: false
	Id string `yaml:"id,omitempty" json:"id,omitempty" cty:"id"`

	// Keyring
	// The full path to specific keyring file in C(/etc/apt/trusted.gpg.d/).
	//
	// Default: <no value>
	// Required: false
	Keyring string `yaml:"keyring,omitempty" json:"keyring,omitempty" cty:"keyring"`

	// Keyserver
	// The keyserver to retrieve key from.
	//
	// Default: <no value>
	// Required: false
	Keyserver string `yaml:"keyserver,omitempty" json:"keyserver,omitempty" cty:"keyserver"`

	// State
	// Ensures that the key is present (added) or absent (revoked).
	//
	// Default: present
	// Required: false
	State string `yaml:"state,omitempty" json:"state,omitempty" cty:"state"`

	// Url
	// The URL to retrieve key from.
	//
	// Default: <no value>
	// Required: false
	Url string `yaml:"url,omitempty" json:"url,omitempty" cty:"url"`

	// ValidateCerts
	// If C(no), SSL certificates for the target url will not be validated. This should only be used on personally controlled sites using self-signed certificates.
	//
	// Default: yes
	// Required: false
	ValidateCerts bool `yaml:"validate_certs,omitempty" json:"validate_certs,omitempty" cty:"validate_certs"`
	// contains filtered or unexported fields
}

type AptKeyResult struct {
	types.CommonReturn
	Raw string

	// After
	// List of apt key ids or fingerprints after any modification
	After []string `yaml:"after,omitempty" json:"after,omitempty" cty:"after"`

	// Before
	// List of apt key ids or fingprints before any modifications
	Before []string `yaml:"before,omitempty" json:"before,omitempty" cty:"before"`

	// Fp
	// Fingerprint of the key to import
	Fp string `yaml:"fp,omitempty" json:"fp,omitempty" cty:"fp"`

	// Id
	// key id from source
	Id string `yaml:"id,omitempty" json:"id,omitempty" cty:"id"`

	// KeyId
	// calculated key id, it should be same as 'id', but can be different
	KeyId string `yaml:"key_id,omitempty" json:"key_id,omitempty" cty:"key_id"`

	// ShortId
	// caclulated short key id
	ShortId string `yaml:"short_id,omitempty" json:"short_id,omitempty" cty:"short_id"`
	// contains filtered or unexported fields
}

type AptParams struct {

	// AllowChangeHeldPackages
	// Allows changing the version of a package which is on the apt hold list
	//
	// Default: no
	// Required: false
	AllowChangeHeldPackages bool `yaml:"allow_change_held_packages,omitempty" json:"allow_change_held_packages,omitempty" cty:"allow_change_held_packages"`

	// AllowDowngrade
	// Corresponds to the C(--allow-downgrades) option for I(apt).
	// This option enables the named package and version to replace an already installed higher version of that package.
	// Note that setting I(allow_downgrade=true) can make this module behave in a non-idempotent way.
	// (The task could end up with a set of packages that does not match the complete list of specified packages to install).
	//
	// Default: no
	// Required: false
	AllowDowngrade bool `yaml:"allow_downgrade,omitempty" json:"allow_downgrade,omitempty" cty:"allow_downgrade"`

	// AllowUnauthenticated
	// Ignore if packages cannot be authenticated. This is useful for bootstrapping environments that manage their own apt-key setup.
	// C(allow_unauthenticated) is only supported with state: I(install)/I(present)
	//
	// Default: no
	// Required: false
	AllowUnauthenticated bool `yaml:"allow_unauthenticated,omitempty" json:"allow_unauthenticated,omitempty" cty:"allow_unauthenticated"`

	// Autoclean
	// If C(yes), cleans the local repository of retrieved package files that can no longer be downloaded.
	//
	// Default: no
	// Required: false
	Autoclean bool `yaml:"autoclean,omitempty" json:"autoclean,omitempty" cty:"autoclean"`

	// Autoremove
	// If C(yes), remove unused dependency packages for all module states except I(build-dep). It can also be used as the only option.
	// Previous to version 2.4, autoclean was also an alias for autoremove, now it is its own separate command. See documentation for further information.
	//
	// Default: no
	// Required: false
	Autoremove bool `yaml:"autoremove,omitempty" json:"autoremove,omitempty" cty:"autoremove"`

	// CacheValidTime
	// Update the apt cache if it is older than the I(cache_valid_time). This option is set in seconds.
	// As of Ansible 2.4, if explicitly set, this sets I(update_cache=yes).
	//
	// Default: 0
	// Required: false
	CacheValidTime int `yaml:"cache_valid_time,omitempty" json:"cache_valid_time,omitempty" cty:"cache_valid_time"`

	// Clean
	// Run the equivalent of C(apt-get clean) to clear out the local repository of retrieved package files. It removes everything but the lock file from /var/cache/apt/archives/ and /var/cache/apt/archives/partial/.
	// Can be run as part of the package installation (clean runs before install) or as a separate step.
	//
	// Default: no
	// Required: false
	Clean bool `yaml:"clean,omitempty" json:"clean,omitempty" cty:"clean"`

	// Deb
	// Path to a .deb package on the remote machine.
	// If :// in the path, ansible will attempt to download deb before installing. (Version added 2.1)
	// Requires the C(xz-utils) package to extract the control file of the deb package to install.
	//
	// Default: <no value>
	// Required: false
	Deb string `yaml:"deb,omitempty" json:"deb,omitempty" cty:"deb"`

	// DefaultRelease
	// Corresponds to the C(-t) option for I(apt) and sets pin priorities
	//
	// Default: <no value>
	// Required: false
	DefaultRelease string `yaml:"default_release,omitempty" json:"default_release,omitempty" cty:"default_release"`

	// DpkgOptions
	// Add dpkg options to apt command. Defaults to '-o "Dpkg::Options::=--force-confdef" -o "Dpkg::Options::=--force-confold"'
	// Options should be supplied as comma separated list
	//
	// Default: force-confdef,force-confold
	// Required: false
	DpkgOptions string `yaml:"dpkg_options,omitempty" json:"dpkg_options,omitempty" cty:"dpkg_options"`

	// FailOnAutoremove
	// Corresponds to the C(--no-remove) option for C(apt).
	// If C(yes), it is ensured that no packages will be removed or the task will fail.
	// C(fail_on_autoremove) is only supported with state except C(absent)
	//
	// Default: no
	// Required: false
	FailOnAutoremove bool `yaml:"fail_on_autoremove,omitempty" json:"fail_on_autoremove,omitempty" cty:"fail_on_autoremove"`

	// Force
	// Corresponds to the C(--force-yes) to I(apt-get) and implies C(allow_unauthenticated: yes) and C(allow_downgrade: yes)
	// This option will disable checking both the packages' signatures and the certificates of the web servers they are downloaded from.
	// This option *is not* the equivalent of passing the C(-f) flag to I(apt-get) on the command line
	// **This is a destructive operation with the potential to destroy your system, and it should almost never be used.** Please also see C(man apt-get) for more information.
	//
	// Default: no
	// Required: false
	Force bool `yaml:"force,omitempty" json:"force,omitempty" cty:"force"`

	// ForceAptGet
	// Force usage of apt-get instead of aptitude
	//
	// Default: no
	// Required: false
	ForceAptGet bool `yaml:"force_apt_get,omitempty" json:"force_apt_get,omitempty" cty:"force_apt_get"`

	// InstallRecommends
	// Corresponds to the C(--no-install-recommends) option for I(apt). C(yes) installs recommended packages.  C(no) does not install recommended packages. By default, Ansible will use the same defaults as the operating system. Suggested packages are never installed.
	//
	// Default: <no value>
	// Required: false
	InstallRecommends bool `yaml:"install_recommends,omitempty" json:"install_recommends,omitempty" cty:"install_recommends"`

	// LockTimeout
	// How many seconds will this action wait to acquire a lock on the apt db.
	// Sometimes there is a transitory lock and this will retry at least until timeout is hit.
	//
	// Default: 60
	// Required: false
	LockTimeout int `yaml:"lock_timeout,omitempty" json:"lock_timeout,omitempty" cty:"lock_timeout"`

	// Name
	// A list of package names, like C(foo), or package specifier with version, like C(foo=1.0) or C(foo>=1.0). Name wildcards (fnmatch) like C(apt*) and version wildcards like C(foo=1.0*) are also supported.
	//
	// Default: <no value>
	// Required: false
	Name []string `yaml:"name,omitempty" json:"name,omitempty" cty:"name"`

	// OnlyUpgrade
	// Only upgrade a package if it is already installed.
	//
	// Default: no
	// Required: false
	OnlyUpgrade bool `yaml:"only_upgrade,omitempty" json:"only_upgrade,omitempty" cty:"only_upgrade"`

	// PolicyRcD
	// Force the exit code of /usr/sbin/policy-rc.d.
	// For example, if I(policy_rc_d=101) the installed package will not trigger a service start.
	// If /usr/sbin/policy-rc.d already exists, it is backed up and restored after the package installation.
	// If C(null), the /usr/sbin/policy-rc.d isn't created/changed.
	//
	// Default: <no value>
	// Required: false
	PolicyRcD int `yaml:"policy_rc_d,omitempty" json:"policy_rc_d,omitempty" cty:"policy_rc_d"`

	// Purge
	// Will force purging of configuration files if the module state is set to I(absent).
	//
	// Default: no
	// Required: false
	Purge bool `yaml:"purge,omitempty" json:"purge,omitempty" cty:"purge"`

	// State
	// Indicates the desired package state. C(latest) ensures that the latest version is installed. C(build-dep) ensures the package build dependencies are installed. C(fixed) attempt to correct a system with broken dependencies in place.
	//
	// Default: present
	// Required: false
	State string `yaml:"state,omitempty" json:"state,omitempty" cty:"state"`

	// UpdateCache
	// Run the equivalent of C(apt-get update) before the operation. Can be run as part of the package installation or as a separate step.
	// Default is not to update the cache.
	//
	// Default: <no value>
	// Required: false
	UpdateCache bool `yaml:"update_cache,omitempty" json:"update_cache,omitempty" cty:"update_cache"`

	// UpdateCacheRetries
	// Amount of retries if the cache update fails. Also see I(update_cache_retry_max_delay).
	//
	// Default: 5
	// Required: false
	UpdateCacheRetries int `yaml:"update_cache_retries,omitempty" json:"update_cache_retries,omitempty" cty:"update_cache_retries"`

	// UpdateCacheRetryMaxDelay
	// Use an exponential backoff delay for each retry (see I(update_cache_retries)) up to this max delay in seconds.
	//
	// Default: 12
	// Required: false
	UpdateCacheRetryMaxDelay int `` /* 126-byte string literal not displayed */

	// Upgrade
	// If yes or safe, performs an aptitude safe-upgrade.
	// If full, performs an aptitude full-upgrade.
	// If dist, performs an apt-get dist-upgrade.
	// Note: This does not upgrade a specific package, use state=latest for that.
	// Note: Since 2.4, apt-get is used as a fall-back if aptitude is not present.
	//
	// Default: no
	// Required: false
	Upgrade string `yaml:"upgrade,omitempty" json:"upgrade,omitempty" cty:"upgrade"`
	// contains filtered or unexported fields
}

type AptRepository struct {
	Params AptRepositoryParams
	Result AptRepositoryResult
}

type AptRepositoryParams struct {

	// Codename
	// Override the distribution codename to use for PPA repositories. Should usually only be set when working with a PPA on a non-Ubuntu target (for example, Debian or Mint).
	//
	// Default: <no value>
	// Required: false
	Codename string `yaml:"codename,omitempty" json:"codename,omitempty" cty:"codename"`

	// Filename
	// Sets the name of the source list file in sources.list.d. Defaults to a file name based on the repository source url. The .list extension will be automatically added.
	//
	// Default: <no value>
	// Required: false
	Filename string `yaml:"filename,omitempty" json:"filename,omitempty" cty:"filename"`

	// InstallPythonApt
	// Whether to automatically try to install the Python apt library or not, if it is not already installed. Without this library, the module does not work.
	// Runs C(apt-get install python-apt) for Python 2, and C(apt-get install python3-apt) for Python 3.
	// Only works with the system Python 2 or Python 3. If you are using a Python on the remote that is not the system Python, set I(install_python_apt=false) and ensure that the Python apt library for your Python version is installed some other way.
	//
	// Default: true
	// Required: false
	InstallPythonApt bool `yaml:"install_python_apt,omitempty" json:"install_python_apt,omitempty" cty:"install_python_apt"`

	// Mode
	// The octal mode for newly created files in sources.list.d.
	// Default is what system uses (probably 0644).
	//
	// Default: <no value>
	// Required: false
	Mode string `yaml:"mode,omitempty" json:"mode,omitempty" cty:"mode"`

	// Repo
	// A source string for the repository.
	//
	// Default: <no value>
	// Required: true
	Repo string `yaml:"repo,omitempty" json:"repo,omitempty" cty:"repo"`

	// State
	// A source string state.
	//
	// Default: present
	// Required: false
	State string `yaml:"state,omitempty" json:"state,omitempty" cty:"state"`

	// UpdateCache
	// Run the equivalent of C(apt-get update) when a change occurs.  Cache updates are run after making changes.
	//
	// Default: yes
	// Required: false
	UpdateCache bool `yaml:"update_cache,omitempty" json:"update_cache,omitempty" cty:"update_cache"`

	// UpdateCacheRetries
	// Amount of retries if the cache update fails. Also see I(update_cache_retry_max_delay).
	//
	// Default: 5
	// Required: false
	UpdateCacheRetries int `yaml:"update_cache_retries,omitempty" json:"update_cache_retries,omitempty" cty:"update_cache_retries"`

	// UpdateCacheRetryMaxDelay
	// Use an exponential backoff delay for each retry (see I(update_cache_retries)) up to this max delay in seconds.
	//
	// Default: 12
	// Required: false
	UpdateCacheRetryMaxDelay int `` /* 126-byte string literal not displayed */

	// ValidateCerts
	// If C(no), SSL certificates for the target repo will not be validated. This should only be used on personally controlled sites using self-signed certificates.
	//
	// Default: yes
	// Required: false
	ValidateCerts bool `yaml:"validate_certs,omitempty" json:"validate_certs,omitempty" cty:"validate_certs"`
	// contains filtered or unexported fields
}

type AptRepositoryResult struct {
	types.CommonReturn
	Raw string
	// contains filtered or unexported fields
}

type AptResult struct {
	types.CommonReturn
	Raw string

	// CacheUpdateTime
	// time of the last cache update (0 if unknown)
	CacheUpdateTime int `yaml:"cache_update_time,omitempty" json:"cache_update_time,omitempty" cty:"cache_update_time"`

	// CacheUpdated
	// if the cache was updated or not
	CacheUpdated bool `yaml:"cache_updated,omitempty" json:"cache_updated,omitempty" cty:"cache_updated"`

	// Stderr
	// error output from apt
	Stderr string `yaml:"stderr,omitempty" json:"stderr,omitempty" cty:"stderr"`

	// Stdout
	// output from apt
	Stdout string `yaml:"stdout,omitempty" json:"stdout,omitempty" cty:"stdout"`
	// contains filtered or unexported fields
}

type Assemble struct {
	Params AssembleParams
	Result AssembleResult
}

type AssembleParams struct {

	// Backup
	// Create a backup file (if C(yes)), including the timestamp information so you can get the original file back if you somehow clobbered it incorrectly.
	//
	// Default: no
	// Required: false
	Backup bool `yaml:"backup,omitempty" json:"backup,omitempty" cty:"backup"`

	// Delimiter
	// A delimiter to separate the file contents.
	//
	// Default: <no value>
	// Required: false
	Delimiter string `yaml:"delimiter,omitempty" json:"delimiter,omitempty" cty:"delimiter"`

	// Dest
	// A file to create using the concatenation of all of the source files.
	//
	// Default: <no value>
	// Required: true
	Dest string `yaml:"dest,omitempty" json:"dest,omitempty" cty:"dest"`

	// IgnoreHidden
	// A boolean that controls if files that start with a '.' will be included or not.
	//
	// Default: no
	// Required: false
	IgnoreHidden bool `yaml:"ignore_hidden,omitempty" json:"ignore_hidden,omitempty" cty:"ignore_hidden"`

	// Regexp
	// Assemble files only if C(regex) matches the filename.
	// If not set, all files are assembled.
	// Every "\" (backslash) must be escaped as "\\" to comply to YAML syntax.
	// Uses L(Python regular expressions,https://docs.python.org/3/library/re.html).
	//
	// Default: <no value>
	// Required: false
	Regexp string `yaml:"regexp,omitempty" json:"regexp,omitempty" cty:"regexp"`

	// RemoteSrc
	// If C(no), it will search for src at originating/master machine.
	// If C(yes), it will go to the remote/target machine for the src.
	//
	// Default: yes
	// Required: false
	RemoteSrc bool `yaml:"remote_src,omitempty" json:"remote_src,omitempty" cty:"remote_src"`

	// Src
	// An already existing directory full of source files.
	//
	// Default: <no value>
	// Required: true
	Src string `yaml:"src,omitempty" json:"src,omitempty" cty:"src"`

	// Validate
	// The validation command to run before copying into place.
	// The path to the file to validate is passed in via '%s' which must be present as in the sshd example below.
	// The command is passed securely so shell features like expansion and pipes won't work.
	//
	// Default: <no value>
	// Required: false
	Validate string `yaml:"validate,omitempty" json:"validate,omitempty" cty:"validate"`
	// contains filtered or unexported fields
}

type AssembleResult struct {
	types.CommonReturn
	Raw string
	// contains filtered or unexported fields
}

type AsyncStatus struct {
	Params AsyncStatusParams
	Result AsyncStatusResult
}

type AsyncStatusParams struct {

	// Jid
	// Job or task identifier
	//
	// Default: <no value>
	// Required: true
	Jid string `yaml:"jid,omitempty" json:"jid,omitempty" cty:"jid"`

	// Mode
	// If C(status), obtain the status.
	// If C(cleanup), clean up the async job cache (by default in C(~/.ansible_async/)) for the specified job I(jid).
	//
	// Default: status
	// Required: false
	Mode string `yaml:"mode,omitempty" json:"mode,omitempty" cty:"mode"`
	// contains filtered or unexported fields
}

type AsyncStatusResult struct {
	types.CommonReturn
	Raw string

	// AnsibleJobId
	// The asynchronous job id
	AnsibleJobId string `yaml:"ansible_job_id,omitempty" json:"ansible_job_id,omitempty" cty:"ansible_job_id"`

	// Erased
	// Path to erased job file
	Erased string `yaml:"erased,omitempty" json:"erased,omitempty" cty:"erased"`

	// Finished
	// Whether the asynchronous job has finished (C(1)) or not (C(0))
	Finished int `yaml:"finished,omitempty" json:"finished,omitempty" cty:"finished"`

	// Started
	// Whether the asynchronous job has started (C(1)) or not (C(0))
	Started int `yaml:"started,omitempty" json:"started,omitempty" cty:"started"`

	// Stderr
	// Any errors returned by async_wrapper
	Stderr string `yaml:"stderr,omitempty" json:"stderr,omitempty" cty:"stderr"`

	// Stdout
	// Any output returned by async_wrapper
	Stdout string `yaml:"stdout,omitempty" json:"stdout,omitempty" cty:"stdout"`
	// contains filtered or unexported fields
}

type Blockinfile struct {
	Params BlockinfileParams
	Result BlockinfileResult
}

type BlockinfileParams struct {

	// Backup
	// Create a backup file including the timestamp information so you can get the original file back if you somehow clobbered it incorrectly.
	//
	// Default: no
	// Required: false
	Backup bool `yaml:"backup,omitempty" json:"backup,omitempty" cty:"backup"`

	// Block
	// The text to insert inside the marker lines.
	// If it is missing or an empty string, the block will be removed as if C(state) were specified to C(absent).
	//
	// Default:
	// Required: false
	Block string `yaml:"block,omitempty" json:"block,omitempty" cty:"block"`

	// Create
	// Create a new file if it does not exist.
	//
	// Default: no
	// Required: false
	Create bool `yaml:"create,omitempty" json:"create,omitempty" cty:"create"`

	// Insertafter
	// If specified and no begin/ending C(marker) lines are found, the block will be inserted after the last match of specified regular expression.
	// A special value is available; C(EOF) for inserting the block at the end of the file.
	// If specified regular expression has no matches, C(EOF) will be used instead.
	//
	// Default: EOF
	// Required: false
	Insertafter string `yaml:"insertafter,omitempty" json:"insertafter,omitempty" cty:"insertafter"`

	// Insertbefore
	// If specified and no begin/ending C(marker) lines are found, the block will be inserted before the last match of specified regular expression.
	// A special value is available; C(BOF) for inserting the block at the beginning of the file.
	// If specified regular expression has no matches, the block will be inserted at the end of the file.
	//
	// Default: <no value>
	// Required: false
	Insertbefore string `yaml:"insertbefore,omitempty" json:"insertbefore,omitempty" cty:"insertbefore"`

	// Marker
	// The marker line template.
	// C({mark}) will be replaced with the values in C(marker_begin) (default="BEGIN") and C(marker_end) (default="END").
	// Using a custom marker without the C({mark}) variable may result in the block being repeatedly inserted on subsequent playbook runs.
	//
	// Default: # {mark} ANSIBLE MANAGED BLOCK
	// Required: false
	Marker string `yaml:"marker,omitempty" json:"marker,omitempty" cty:"marker"`

	// MarkerBegin
	// This will be inserted at C({mark}) in the opening ansible block marker.
	//
	// Default: BEGIN
	// Required: false
	MarkerBegin string `yaml:"marker_begin,omitempty" json:"marker_begin,omitempty" cty:"marker_begin"`

	// MarkerEnd
	// This will be inserted at C({mark}) in the closing ansible block marker.
	//
	// Default: END
	// Required: false
	MarkerEnd string `yaml:"marker_end,omitempty" json:"marker_end,omitempty" cty:"marker_end"`

	// Path
	// The file to modify.
	// Before Ansible 2.3 this option was only usable as I(dest), I(destfile) and I(name).
	//
	// Default: <no value>
	// Required: true
	Path string `yaml:"path,omitempty" json:"path,omitempty" cty:"path"`

	// State
	// Whether the block should be there or not.
	//
	// Default: present
	// Required: false
	State string `yaml:"state,omitempty" json:"state,omitempty" cty:"state"`
	// contains filtered or unexported fields
}

type BlockinfileResult struct {
	types.CommonReturn
	Raw string
	// contains filtered or unexported fields
}

type Command struct {
	Params CommandParams
	Result CommandResult
}

type CommandParams struct {

	// Argv
	// Passes the command as a list rather than a string.
	// Use C(argv) to avoid quoting values that would otherwise be interpreted incorrectly (for example "user name").
	// Only the string (free form) or the list (argv) form can be provided, not both.  One or the other must be provided.
	//
	// Default: <no value>
	// Required: false
	Argv []string `yaml:"argv,omitempty" json:"argv,omitempty" cty:"argv"`

	// Chdir
	// Change into this directory before running the command.
	//
	// Default: <no value>
	// Required: false
	Chdir string `yaml:"chdir,omitempty" json:"chdir,omitempty" cty:"chdir"`

	// Cmd
	// The command to run.
	//
	// Default: <no value>
	// Required: false
	Cmd string `yaml:"cmd,omitempty" json:"cmd,omitempty" cty:"cmd"`

	// Creates
	// A filename or (since 2.0) glob pattern. If a matching file already exists, this step B(will not) be run.
	// This is checked before I(removes) is checked.
	//
	// Default: <no value>
	// Required: false
	Creates string `yaml:"creates,omitempty" json:"creates,omitempty" cty:"creates"`

	// FreeForm
	// The command module takes a free form string as a command to run.
	// There is no actual parameter named 'free form'.
	//
	// Default: <no value>
	// Required: false
	FreeForm string `yaml:"free_form,omitempty" json:"free_form,omitempty" cty:"free_form"`

	// Removes
	// A filename or (since 2.0) glob pattern. If a matching file exists, this step B(will) be run.
	// This is checked after I(creates) is checked.
	//
	// Default: <no value>
	// Required: false
	Removes string `yaml:"removes,omitempty" json:"removes,omitempty" cty:"removes"`

	// Stdin
	// Set the stdin of the command directly to the specified value.
	//
	// Default: <no value>
	// Required: false
	Stdin string `yaml:"stdin,omitempty" json:"stdin,omitempty" cty:"stdin"`

	// StdinAddNewline
	// If set to C(yes), append a newline to stdin data.
	//
	// Default: yes
	// Required: false
	StdinAddNewline bool `yaml:"stdin_add_newline,omitempty" json:"stdin_add_newline,omitempty" cty:"stdin_add_newline"`

	// StripEmptyEnds
	// Strip empty lines from the end of stdout/stderr in result.
	//
	// Default: yes
	// Required: false
	StripEmptyEnds bool `yaml:"strip_empty_ends,omitempty" json:"strip_empty_ends,omitempty" cty:"strip_empty_ends"`

	// Warn
	// (deprecated) Enable or disable task warnings.
	// This feature is deprecated and will be removed in 2.14.
	// As of version 2.11, this option is now disabled by default.
	//
	// Default: no
	// Required: false
	Warn bool `yaml:"warn,omitempty" json:"warn,omitempty" cty:"warn"`
	// contains filtered or unexported fields
}

type CommandResult struct {
	types.CommonReturn
	Raw string

	// Cmd
	// The command executed by the task.
	Cmd []string `yaml:"cmd,omitempty" json:"cmd,omitempty" cty:"cmd"`

	// Delta
	// The command execution delta time.
	Delta string `yaml:"delta,omitempty" json:"delta,omitempty" cty:"delta"`

	// End
	// The command execution end time.
	End string `yaml:"end,omitempty" json:"end,omitempty" cty:"end"`

	// Rc
	// The command return code (0 means success).
	Rc int `yaml:"rc,omitempty" json:"rc,omitempty" cty:"rc"`

	// Start
	// The command execution start time.
	Start string `yaml:"start,omitempty" json:"start,omitempty" cty:"start"`

	// Stderr
	// The command standard error.
	Stderr string `yaml:"stderr,omitempty" json:"stderr,omitempty" cty:"stderr"`

	// StderrLines
	// The command standard error split in lines.
	StderrLines []string `yaml:"stderr_lines,omitempty" json:"stderr_lines,omitempty" cty:"stderr_lines"`

	// Stdout
	// The command standard output.
	Stdout string `yaml:"stdout,omitempty" json:"stdout,omitempty" cty:"stdout"`

	// StdoutLines
	// The command standard output split in lines.
	StdoutLines []string `yaml:"stdout_lines,omitempty" json:"stdout_lines,omitempty" cty:"stdout_lines"`
	// contains filtered or unexported fields
}

type Cron struct {
	Params CronParams
	Result CronResult
}

type CronParams struct {

	// Backup
	// If set, create a backup of the crontab before it is modified. The location of the backup is returned in the C(backup_file) variable by this module.
	//
	// Default: no
	// Required: false
	Backup bool `yaml:"backup,omitempty" json:"backup,omitempty" cty:"backup"`

	// CronFile
	// If specified, uses this file instead of an individual user's crontab. The assumption is that this file is exclusively managed by the module, do not use if the file contains multiple entries, NEVER use for /etc/crontab.
	// If this is a relative path, it is interpreted with respect to I(/etc/cron.d).
	// Many linux distros expect (and some require) the filename portion to consist solely of upper- and lower-case letters, digits, underscores, and hyphens.
	// Using this parameter requires you to specify the I(user) as well, unless I(state) is not I(present).
	// Either this parameter or I(name) is required
	//
	// Default: <no value>
	// Required: false
	CronFile string `yaml:"cron_file,omitempty" json:"cron_file,omitempty" cty:"cron_file"`

	// Day
	// Day of the month the job should run (C(1-31), C(*), C(*/2), and so on).
	//
	// Default: *
	// Required: false
	Day string `yaml:"day,omitempty" json:"day,omitempty" cty:"day"`

	// Disabled
	// If the job should be disabled (commented out) in the crontab.
	// Only has effect if I(state=present).
	//
	// Default: no
	// Required: false
	Disabled bool `yaml:"disabled,omitempty" json:"disabled,omitempty" cty:"disabled"`

	// Env
	// If set, manages a crontab's environment variable.
	// New variables are added on top of crontab.
	// I(name) and I(value) parameters are the name and the value of environment variable.
	//
	// Default: false
	// Required: false
	Env bool `yaml:"env,omitempty" json:"env,omitempty" cty:"env"`

	// Hour
	// Hour when the job should run (C(0-23), C(*), C(*/2), and so on).
	//
	// Default: *
	// Required: false
	Hour string `yaml:"hour,omitempty" json:"hour,omitempty" cty:"hour"`

	// Insertafter
	// Used with I(state=present) and I(env).
	// If specified, the environment variable will be inserted after the declaration of specified environment variable.
	//
	// Default: <no value>
	// Required: false
	Insertafter string `yaml:"insertafter,omitempty" json:"insertafter,omitempty" cty:"insertafter"`

	// Insertbefore
	// Used with I(state=present) and I(env).
	// If specified, the environment variable will be inserted before the declaration of specified environment variable.
	//
	// Default: <no value>
	// Required: false
	Insertbefore string `yaml:"insertbefore,omitempty" json:"insertbefore,omitempty" cty:"insertbefore"`

	// Job
	// The command to execute or, if env is set, the value of environment variable.
	// The command should not contain line breaks.
	// Required if I(state=present).
	//
	// Default: <no value>
	// Required: false
	Job string `yaml:"job,omitempty" json:"job,omitempty" cty:"job"`

	// Minute
	// Minute when the job should run (C(0-59), C(*), C(*/2), and so on).
	//
	// Default: *
	// Required: false
	Minute string `yaml:"minute,omitempty" json:"minute,omitempty" cty:"minute"`

	// Month
	// Month of the year the job should run (C(1-12), C(*), C(*/2), and so on).
	//
	// Default: *
	// Required: false
	Month string `yaml:"month,omitempty" json:"month,omitempty" cty:"month"`

	// Name
	// Description of a crontab entry or, if env is set, the name of environment variable.
	// This parameter is always required as of ansible-core 2.12.
	//
	// Default: <no value>
	// Required: true
	Name string `yaml:"name,omitempty" json:"name,omitempty" cty:"name"`

	// SpecialTime
	// Special time specification nickname.
	//
	// Default: <no value>
	// Required: false
	SpecialTime string `yaml:"special_time,omitempty" json:"special_time,omitempty" cty:"special_time"`

	// State
	// Whether to ensure the job or environment variable is present or absent.
	//
	// Default: present
	// Required: false
	State string `yaml:"state,omitempty" json:"state,omitempty" cty:"state"`

	// User
	// The specific user whose crontab should be modified.
	// When unset, this parameter defaults to the current user.
	//
	// Default: <no value>
	// Required: false
	User string `yaml:"user,omitempty" json:"user,omitempty" cty:"user"`

	// Weekday
	// Day of the week that the job should run (C(0-6) for Sunday-Saturday, C(*), and so on).
	//
	// Default: *
	// Required: false
	Weekday string `yaml:"weekday,omitempty" json:"weekday,omitempty" cty:"weekday"`
	// contains filtered or unexported fields
}

type CronResult struct {
	types.CommonReturn
	Raw string
	// contains filtered or unexported fields
}

type Debconf struct {
	Params DebconfParams
	Result DebconfResult
}

type DebconfParams struct {

	// Name
	// Name of package to configure.
	//
	// Default: <no value>
	// Required: true
	Name string `yaml:"name,omitempty" json:"name,omitempty" cty:"name"`

	// Question
	// A debconf configuration setting.
	//
	// Default: <no value>
	// Required: false
	Question string `yaml:"question,omitempty" json:"question,omitempty" cty:"question"`

	// Unseen
	// Do not set 'seen' flag when pre-seeding.
	//
	// Default: false
	// Required: false
	Unseen bool `yaml:"unseen,omitempty" json:"unseen,omitempty" cty:"unseen"`

	// Value
	// Value to set the configuration to.
	//
	// Default: <no value>
	// Required: false
	Value string `yaml:"value,omitempty" json:"value,omitempty" cty:"value"`

	// Vtype
	// The type of the value supplied.
	// It is highly recommended to add I(no_log=True) to task while specifying I(vtype=password).
	// C(seen) was added in Ansible 2.2.
	//
	// Default: <no value>
	// Required: false
	Vtype string `yaml:"vtype,omitempty" json:"vtype,omitempty" cty:"vtype"`
	// contains filtered or unexported fields
}

type DebconfResult struct {
	types.CommonReturn
	Raw string
	// contains filtered or unexported fields
}

type Dnf struct {
	Params DnfParams
	Result DnfResult
}

type DnfParams struct {

	// AllowDowngrade
	// Specify if the named package and version is allowed to downgrade a maybe already installed higher version of that package. Note that setting allow_downgrade=True can make this module behave in a non-idempotent way. The task could end up with a set of packages that does not match the complete list of specified packages to install (because dependencies between the downgraded package and others can cause changes to the packages which were in the earlier transaction).
	//
	// Default: no
	// Required: false
	AllowDowngrade bool `yaml:"allow_downgrade,omitempty" json:"allow_downgrade,omitempty" cty:"allow_downgrade"`

	// Allowerasing
	// If C(yes) it allows  erasing  of  installed  packages to resolve dependencies.
	//
	// Default: no
	// Required: false
	Allowerasing bool `yaml:"allowerasing,omitempty" json:"allowerasing,omitempty" cty:"allowerasing"`

	// Autoremove
	// If C(yes), removes all "leaf" packages from the system that were originally installed as dependencies of user-installed packages but which are no longer required by any such package. Should be used alone or when state is I(absent)
	//
	// Default: no
	// Required: false
	Autoremove bool `yaml:"autoremove,omitempty" json:"autoremove,omitempty" cty:"autoremove"`

	// Bugfix
	// If set to C(yes), and C(state=latest) then only installs updates that have been marked bugfix related.
	// Note that, similar to C(dnf upgrade-minimal), this filter applies to dependencies as well.
	//
	// Default: no
	// Required: false
	Bugfix bool `yaml:"bugfix,omitempty" json:"bugfix,omitempty" cty:"bugfix"`

	// Cacheonly
	// Tells dnf to run entirely from system cache; does not download or update metadata.
	//
	// Default: no
	// Required: false
	Cacheonly bool `yaml:"cacheonly,omitempty" json:"cacheonly,omitempty" cty:"cacheonly"`

	// ConfFile
	// The remote dnf configuration file to use for the transaction.
	//
	// Default: <no value>
	// Required: false
	ConfFile string `yaml:"conf_file,omitempty" json:"conf_file,omitempty" cty:"conf_file"`

	// DisableExcludes
	// Disable the excludes defined in DNF config files.
	// If set to C(all), disables all excludes.
	// If set to C(main), disable excludes defined in [main] in dnf.conf.
	// If set to C(repoid), disable excludes defined for given repo id.
	//
	// Default: <no value>
	// Required: false
	DisableExcludes string `yaml:"disable_excludes,omitempty" json:"disable_excludes,omitempty" cty:"disable_excludes"`

	// DisableGpgCheck
	// Whether to disable the GPG checking of signatures of packages being installed. Has an effect only if state is I(present) or I(latest).
	// This setting affects packages installed from a repository as well as "local" packages installed from the filesystem or a URL.
	//
	// Default: no
	// Required: false
	DisableGpgCheck bool `yaml:"disable_gpg_check,omitempty" json:"disable_gpg_check,omitempty" cty:"disable_gpg_check"`

	// DisablePlugin
	// I(Plugin) name to disable for the install/update operation. The disabled plugins will not persist beyond the transaction.
	//
	// Default: <no value>
	// Required: false
	DisablePlugin []string `yaml:"disable_plugin,omitempty" json:"disable_plugin,omitempty" cty:"disable_plugin"`

	// Disablerepo
	// I(Repoid) of repositories to disable for the install/update operation. These repos will not persist beyond the transaction. When specifying multiple repos, separate them with a ",".
	//
	// Default: <no value>
	// Required: false
	Disablerepo []string `yaml:"disablerepo,omitempty" json:"disablerepo,omitempty" cty:"disablerepo"`

	// DownloadDir
	// Specifies an alternate directory to store packages.
	// Has an effect only if I(download_only) is specified.
	//
	// Default: <no value>
	// Required: false
	DownloadDir string `yaml:"download_dir,omitempty" json:"download_dir,omitempty" cty:"download_dir"`

	// DownloadOnly
	// Only download the packages, do not install them.
	//
	// Default: no
	// Required: false
	DownloadOnly bool `yaml:"download_only,omitempty" json:"download_only,omitempty" cty:"download_only"`

	// EnablePlugin
	// I(Plugin) name to enable for the install/update operation. The enabled plugin will not persist beyond the transaction.
	//
	// Default: <no value>
	// Required: false
	EnablePlugin []string `yaml:"enable_plugin,omitempty" json:"enable_plugin,omitempty" cty:"enable_plugin"`

	// Enablerepo
	// I(Repoid) of repositories to enable for the install/update operation. These repos will not persist beyond the transaction. When specifying multiple repos, separate them with a ",".
	//
	// Default: <no value>
	// Required: false
	Enablerepo []string `yaml:"enablerepo,omitempty" json:"enablerepo,omitempty" cty:"enablerepo"`

	// Exclude
	// Package name(s) to exclude when state=present, or latest. This can be a list or a comma separated string.
	//
	// Default: <no value>
	// Required: false
	Exclude []string `yaml:"exclude,omitempty" json:"exclude,omitempty" cty:"exclude"`

	// InstallRepoquery
	// This is effectively a no-op in DNF as it is not needed with DNF, but is an accepted parameter for feature parity/compatibility with the I(yum) module.
	//
	// Default: yes
	// Required: false
	InstallRepoquery bool `yaml:"install_repoquery,omitempty" json:"install_repoquery,omitempty" cty:"install_repoquery"`

	// InstallWeakDeps
	// Will also install all packages linked by a weak dependency relation.
	//
	// Default: yes
	// Required: false
	InstallWeakDeps bool `yaml:"install_weak_deps,omitempty" json:"install_weak_deps,omitempty" cty:"install_weak_deps"`

	// Installroot
	// Specifies an alternative installroot, relative to which all packages will be installed.
	//
	// Default: /
	// Required: false
	Installroot string `yaml:"installroot,omitempty" json:"installroot,omitempty" cty:"installroot"`

	// List
	// Various (non-idempotent) commands for usage with C(/usr/bin/ansible) and I(not) playbooks. See examples.
	//
	// Default: <no value>
	// Required: false
	List string `yaml:"list,omitempty" json:"list,omitempty" cty:"list"`

	// LockTimeout
	// Amount of time to wait for the dnf lockfile to be freed.
	//
	// Default: 30
	// Required: false
	LockTimeout int `yaml:"lock_timeout,omitempty" json:"lock_timeout,omitempty" cty:"lock_timeout"`

	// Name
	// A package name or package specifier with version, like C(name-1.0). When using state=latest, this can be '*' which means run: dnf -y update. You can also pass a url or a local path to a rpm file. To operate on several packages this can accept a comma separated string of packages or a list of packages.
	// Comparison operators for package version are valid here C(>), C(<), C(>=), C(<=). Example - C(name>=1.0)
	// You can also pass an absolute path for a binary which is provided by the package to install. See examples for more information.
	//
	// Default: <no value>
	// Required: true
	Name []string `yaml:"name,omitempty" json:"name,omitempty" cty:"name"`

	// Nobest
	// Set best option to False, so that transactions are not limited to best candidates only.
	//
	// Default: no
	// Required: false
	Nobest bool `yaml:"nobest,omitempty" json:"nobest,omitempty" cty:"nobest"`

	// Releasever
	// Specifies an alternative release from which all packages will be installed.
	//
	// Default: <no value>
	// Required: false
	Releasever string `yaml:"releasever,omitempty" json:"releasever,omitempty" cty:"releasever"`

	// Security
	// If set to C(yes), and C(state=latest) then only installs updates that have been marked security related.
	// Note that, similar to C(dnf upgrade-minimal), this filter applies to dependencies as well.
	//
	// Default: no
	// Required: false
	Security bool `yaml:"security,omitempty" json:"security,omitempty" cty:"security"`

	// SkipBroken
	// Skip all unavailable packages or packages with broken dependencies without raising an error. Equivalent to passing the --skip-broken option.
	//
	// Default: no
	// Required: false
	SkipBroken bool `yaml:"skip_broken,omitempty" json:"skip_broken,omitempty" cty:"skip_broken"`

	// Sslverify
	// Disables SSL validation of the repository server for this transaction.
	// This should be set to C(no) if one of the configured repositories is using an untrusted or self-signed certificate.
	//
	// Default: yes
	// Required: false
	Sslverify bool `yaml:"sslverify,omitempty" json:"sslverify,omitempty" cty:"sslverify"`

	// State
	// Whether to install (C(present), C(latest)), or remove (C(absent)) a package.
	// Default is C(None), however in effect the default action is C(present) unless the C(autoremove) option is enabled for this module, then C(absent) is inferred.
	//
	// Default: <no value>
	// Required: false
	State string `yaml:"state,omitempty" json:"state,omitempty" cty:"state"`

	// UpdateCache
	// Force dnf to check if cache is out of date and redownload if needed. Has an effect only if state is I(present) or I(latest).
	//
	// Default: no
	// Required: false
	UpdateCache bool `yaml:"update_cache,omitempty" json:"update_cache,omitempty" cty:"update_cache"`

	// UpdateOnly
	// When using latest, only update installed packages. Do not install packages.
	// Has an effect only if state is I(latest)
	//
	// Default: no
	// Required: false
	UpdateOnly bool `yaml:"update_only,omitempty" json:"update_only,omitempty" cty:"update_only"`

	// ValidateCerts
	// This only applies if using a https url as the source of the rpm. e.g. for localinstall. If set to C(no), the SSL certificates will not be validated.
	// This should only set to C(no) used on personally controlled sites using self-signed certificates as it avoids verifying the source site.
	//
	// Default: yes
	// Required: false
	ValidateCerts bool `yaml:"validate_certs,omitempty" json:"validate_certs,omitempty" cty:"validate_certs"`
	// contains filtered or unexported fields
}

type DnfResult struct {
	types.CommonReturn
	Raw string
	// contains filtered or unexported fields
}

type DpkgSelections struct {
	Params DpkgSelectionsParams
	Result DpkgSelectionsResult
}

type DpkgSelectionsParams struct {

	// Name
	// Name of the package.
	//
	// Default: <no value>
	// Required: true
	Name string `yaml:"name,omitempty" json:"name,omitempty" cty:"name"`

	// Selection
	// The selection state to set the package to.
	//
	// Default: <no value>
	// Required: true
	Selection string `yaml:"selection,omitempty" json:"selection,omitempty" cty:"selection"`
	// contains filtered or unexported fields
}

type DpkgSelectionsResult struct {
	types.CommonReturn
	Raw string
	// contains filtered or unexported fields
}

type Expect struct {
	Params ExpectParams
	Result ExpectResult
}

type ExpectParams struct {

	// Chdir
	// Change into this directory before running the command.
	//
	// Default: <no value>
	// Required: false
	Chdir string `yaml:"chdir,omitempty" json:"chdir,omitempty" cty:"chdir"`

	// Command
	// The command module takes command to run.
	//
	// Default: <no value>
	// Required: true
	Command string `yaml:"command,omitempty" json:"command,omitempty" cty:"command"`

	// Creates
	// A filename, when it already exists, this step will B(not) be run.
	//
	// Default: <no value>
	// Required: false
	Creates string `yaml:"creates,omitempty" json:"creates,omitempty" cty:"creates"`

	// Echo
	// Whether or not to echo out your response strings.
	//
	// Default: false
	// Required: false
	Echo bool `yaml:"echo,omitempty" json:"echo,omitempty" cty:"echo"`

	// Removes
	// A filename, when it does not exist, this step will B(not) be run.
	//
	// Default: <no value>
	// Required: false
	Removes string `yaml:"removes,omitempty" json:"removes,omitempty" cty:"removes"`

	// Responses
	// Mapping of expected string/regex and string to respond with. If the response is a list, successive matches return successive responses. List functionality is new in 2.1.
	//
	// Default: <no value>
	// Required: true
	Responses map[string]string `yaml:"responses,omitempty" json:"responses,omitempty" cty:"responses"`

	// Timeout
	// Amount of time in seconds to wait for the expected strings. Use C(null) to disable timeout.
	//
	// Default: 30
	// Required: false
	Timeout int `yaml:"timeout,omitempty" json:"timeout,omitempty" cty:"timeout"`
	// contains filtered or unexported fields
}

type ExpectResult struct {
	types.CommonReturn
	Raw string
	// contains filtered or unexported fields
}

type File struct {
	Params FileParams
	Result FileResult
}

type FileParams struct {

	// AccessTime
	// This parameter indicates the time the file's access time should be set to.
	// Should be C(preserve) when no modification is required, C(YYYYMMDDHHMM.SS) when using default time format, or C(now).
	// Default is C(None) meaning that C(preserve) is the default for C(state=[file,directory,link,hard]) and C(now) is default for C(state=touch).
	//
	// Default: <no value>
	// Required: false
	AccessTime string `yaml:"access_time,omitempty" json:"access_time,omitempty" cty:"access_time"`

	// AccessTimeFormat
	// When used with C(access_time), indicates the time format that must be used.
	// Based on default Python format (see time.strftime doc).
	//
	// Default: %Y%m%d%H%M.%S
	// Required: false
	AccessTimeFormat string `yaml:"access_time_format,omitempty" json:"access_time_format,omitempty" cty:"access_time_format"`

	// Follow
	// This flag indicates that filesystem links, if they exist, should be followed.
	// Previous to Ansible 2.5, this was C(no) by default.
	//
	// Default: yes
	// Required: false
	Follow bool `yaml:"follow,omitempty" json:"follow,omitempty" cty:"follow"`

	//
	// Default: no
	// Required: false
	Force bool `yaml:"force,omitempty" json:"force,omitempty" cty:"force"`

	// ModificationTime
	// This parameter indicates the time the file's modification time should be set to.
	// Should be C(preserve) when no modification is required, C(YYYYMMDDHHMM.SS) when using default time format, or C(now).
	// Default is None meaning that C(preserve) is the default for C(state=[file,directory,link,hard]) and C(now) is default for C(state=touch).
	//
	// Default: <no value>
	// Required: false
	ModificationTime string `yaml:"modification_time,omitempty" json:"modification_time,omitempty" cty:"modification_time"`

	// ModificationTimeFormat
	// When used with C(modification_time), indicates the time format that must be used.
	// Based on default Python format (see time.strftime doc).
	//
	// Default: %Y%m%d%H%M.%S
	// Required: false
	ModificationTimeFormat string `yaml:"modification_time_format,omitempty" json:"modification_time_format,omitempty" cty:"modification_time_format"`

	// Path
	// Path to the file being managed.
	//
	// Default: <no value>
	// Required: true
	Path string `yaml:"path,omitempty" json:"path,omitempty" cty:"path"`

	// Recurse
	// Recursively set the specified file attributes on directory contents.
	// This applies only when C(state) is set to C(directory).
	//
	// Default: no
	// Required: false
	Recurse bool `yaml:"recurse,omitempty" json:"recurse,omitempty" cty:"recurse"`

	// Src
	// Path of the file to link to.
	// This applies only to C(state=link) and C(state=hard).
	// For C(state=link), this will also accept a non-existing path.
	// Relative paths are relative to the file being created (C(path)) which is how the Unix command C(ln -s SRC DEST) treats relative paths.
	//
	// Default: <no value>
	// Required: false
	Src string `yaml:"src,omitempty" json:"src,omitempty" cty:"src"`

	// State
	// If C(absent), directories will be recursively deleted, and files or symlinks will be unlinked. In the case of a directory, if C(diff) is declared, you will see the files and folders deleted listed under C(path_contents). Note that C(absent) will not cause C(file) to fail if the C(path) does not exist as the state did not change.
	// If C(directory), all intermediate subdirectories will be created if they do not exist. Since Ansible 1.7 they will be created with the supplied permissions.
	// If C(file), with no other options, returns the current state of C(path).
	// If C(file), even with other options (such as C(mode)), the file will be modified if it exists but will NOT be created if it does not exist. Set to C(touch) or use the M(ansible.builtin.copy) or M(ansible.builtin.template) module if you want to create the file if it does not exist.
	// If C(hard), the hard link will be created or changed.
	// If C(link), the symbolic link will be created or changed.
	// If C(touch) (new in 1.4), an empty file will be created if the file does not exist, while an existing file or directory will receive updated file access and modification times (similar to the way C(touch) works from the command line).
	//
	// Default: file
	// Required: false
	State string `yaml:"state,omitempty" json:"state,omitempty" cty:"state"`
	// contains filtered or unexported fields
}

type FileResult struct {
	types.CommonReturn
	Raw string

	// Dest
	// Destination file/path, equal to the value passed to I(path).
	Dest string `yaml:"dest,omitempty" json:"dest,omitempty" cty:"dest"`

	// Path
	// Destination file/path, equal to the value passed to I(path).
	Path string `yaml:"path,omitempty" json:"path,omitempty" cty:"path"`
	// contains filtered or unexported fields
}

type Find struct {
	Params FindParams
	Result FindResult
}

type FindParams struct {

	// Age
	// Select files whose age is equal to or greater than the specified time.
	// Use a negative age to find files equal to or less than the specified time.
	// You can choose seconds, minutes, hours, days, or weeks by specifying the first letter of any of those words (e.g., "1w").
	//
	// Default: <no value>
	// Required: false
	Age string `yaml:"age,omitempty" json:"age,omitempty" cty:"age"`

	// AgeStamp
	// Choose the file property against which we compare age.
	//
	// Default: mtime
	// Required: false
	AgeStamp string `yaml:"age_stamp,omitempty" json:"age_stamp,omitempty" cty:"age_stamp"`

	// Contains
	// A regular expression or pattern which should be matched against the file content.
	// Works only when I(file_type) is C(file).
	//
	// Default: <no value>
	// Required: false
	Contains string `yaml:"contains,omitempty" json:"contains,omitempty" cty:"contains"`

	// Depth
	// Set the maximum number of levels to descend into.
	// Setting recurse to C(no) will override this value, which is effectively depth 1.
	// Default is unlimited depth.
	//
	// Default: <no value>
	// Required: false
	Depth int `yaml:"depth,omitempty" json:"depth,omitempty" cty:"depth"`

	// Excludes
	// One or more (shell or regex) patterns, which type is controlled by C(use_regex) option.
	// Items whose basenames match an C(excludes) pattern are culled from C(patterns) matches. Multiple patterns can be specified using a list.
	//
	// Default: <no value>
	// Required: false
	Excludes []string `yaml:"excludes,omitempty" json:"excludes,omitempty" cty:"excludes"`

	// FileType
	// Type of file to select.
	// The 'link' and 'any' choices were added in Ansible 2.3.
	//
	// Default: file
	// Required: false
	FileType string `yaml:"file_type,omitempty" json:"file_type,omitempty" cty:"file_type"`

	// Follow
	// Set this to C(yes) to follow symlinks in path for systems with python 2.6+.
	//
	// Default: no
	// Required: false
	Follow bool `yaml:"follow,omitempty" json:"follow,omitempty" cty:"follow"`

	// GetChecksum
	// Set this to C(yes) to retrieve a file's SHA1 checksum.
	//
	// Default: no
	// Required: false
	GetChecksum bool `yaml:"get_checksum,omitempty" json:"get_checksum,omitempty" cty:"get_checksum"`

	// Hidden
	// Set this to C(yes) to include hidden files, otherwise they will be ignored.
	//
	// Default: no
	// Required: false
	Hidden bool `yaml:"hidden,omitempty" json:"hidden,omitempty" cty:"hidden"`

	// Paths
	// List of paths of directories to search. All paths must be fully qualified.
	//
	// Default: <no value>
	// Required: true
	Paths []string `yaml:"paths,omitempty" json:"paths,omitempty" cty:"paths"`

	// Patterns
	// One or more (shell or regex) patterns, which type is controlled by C(use_regex) option.
	// The patterns restrict the list of files to be returned to those whose basenames match at least one of the patterns specified. Multiple patterns can be specified using a list.
	// The pattern is matched against the file base name, excluding the directory.
	// When using regexen, the pattern MUST match the ENTIRE file name, not just parts of it. So if you are looking to match all files ending in .default, you'd need to use '.*\.default' as a regexp and not just '\.default'.
	// This parameter expects a list, which can be either comma separated or YAML. If any of the patterns contain a comma, make sure to put them in a list to avoid splitting the patterns in undesirable ways.
	// Defaults to '*' when C(use_regex=False), or '.*' when C(use_regex=True).
	//
	// Default: []
	// Required: false
	Patterns []string `yaml:"patterns,omitempty" json:"patterns,omitempty" cty:"patterns"`

	// ReadWholeFile
	// When doing a C(contains) search, determines whether the whole file should be read into memory or if the regex should be applied to the file line-by-line.
	// Setting this to C(true) can have performance and memory implications for large files.
	// This uses C(re.search()) instead of C(re.match()).
	//
	// Default: false
	// Required: false
	ReadWholeFile bool `yaml:"read_whole_file,omitempty" json:"read_whole_file,omitempty" cty:"read_whole_file"`

	// Recurse
	// If target is a directory, recursively descend into the directory looking for files.
	//
	// Default: no
	// Required: false
	Recurse bool `yaml:"recurse,omitempty" json:"recurse,omitempty" cty:"recurse"`

	// Size
	// Select files whose size is equal to or greater than the specified size.
	// Use a negative size to find files equal to or less than the specified size.
	// Unqualified values are in bytes but b, k, m, g, and t can be appended to specify bytes, kilobytes, megabytes, gigabytes, and terabytes, respectively.
	// Size is not evaluated for directories.
	//
	// Default: <no value>
	// Required: false
	Size string `yaml:"size,omitempty" json:"size,omitempty" cty:"size"`

	// UseRegex
	// If C(no), the patterns are file globs (shell).
	// If C(yes), they are python regexes.
	//
	// Default: no
	// Required: false
	UseRegex bool `yaml:"use_regex,omitempty" json:"use_regex,omitempty" cty:"use_regex"`
	// contains filtered or unexported fields
}

type FindResult struct {
	types.CommonReturn
	Raw string

	// Examined
	// Number of filesystem objects looked at
	Examined int `yaml:"examined,omitempty" json:"examined,omitempty" cty:"examined"`

	// Files
	// All matches found with the specified criteria (see stat module for full output of each dictionary)
	Files []string `yaml:"files,omitempty" json:"files,omitempty" cty:"files"`

	// Matched
	// Number of matches
	Matched int `yaml:"matched,omitempty" json:"matched,omitempty" cty:"matched"`

	// SkippedPaths
	// skipped paths and reasons they were skipped
	SkippedPaths map[string]string `yaml:"skipped_paths,omitempty" json:"skipped_paths,omitempty" cty:"skipped_paths"`
	// contains filtered or unexported fields
}

type GetUrl struct {
	Params GetUrlParams
	Result GetUrlResult
}

type GetUrlParams struct {

	// Backup
	// Create a backup file including the timestamp information so you can get the original file back if you somehow clobbered it incorrectly.
	//
	// Default: no
	// Required: false
	Backup bool `yaml:"backup,omitempty" json:"backup,omitempty" cty:"backup"`

	// Checksum
	// If a checksum is passed to this parameter, the digest of the destination file will be calculated after it is downloaded to ensure its integrity and verify that the transfer completed successfully. Format: <algorithm>:<checksum|url>, e.g. checksum="sha256:D98291AC[...]B6DC7B97", checksum="sha256:http://example.com/path/sha256sum.txt"
	// If you worry about portability, only the sha1 algorithm is available on all platforms and python versions.
	// The third party hashlib library can be installed for access to additional algorithms.
	// Additionally, if a checksum is passed to this parameter, and the file exist under the C(dest) location, the I(destination_checksum) would be calculated, and if checksum equals I(destination_checksum), the file download would be skipped (unless C(force) is true). If the checksum does not equal I(destination_checksum), the destination file is deleted.
	//
	// Default:
	// Required: false
	Checksum string `yaml:"checksum,omitempty" json:"checksum,omitempty" cty:"checksum"`

	// ClientCert
	// PEM formatted certificate chain file to be used for SSL client authentication.
	// This file can also include the key as well, and if the key is included, C(client_key) is not required.
	//
	// Default: <no value>
	// Required: false
	ClientCert string `yaml:"client_cert,omitempty" json:"client_cert,omitempty" cty:"client_cert"`

	// ClientKey
	// PEM formatted file that contains your private key to be used for SSL client authentication.
	// If C(client_cert) contains both the certificate and key, this option is not required.
	//
	// Default: <no value>
	// Required: false
	ClientKey string `yaml:"client_key,omitempty" json:"client_key,omitempty" cty:"client_key"`

	// Dest
	// Absolute path of where to download the file to.
	// If C(dest) is a directory, either the server provided filename or, if none provided, the base name of the URL on the remote server will be used. If a directory, C(force) has no effect.
	// If C(dest) is a directory, the file will always be downloaded (regardless of the C(force) and C(checksum) option), but replaced only if the contents changed.
	//
	// Default: <no value>
	// Required: true
	Dest string `yaml:"dest,omitempty" json:"dest,omitempty" cty:"dest"`

	// Force
	// If C(yes) and C(dest) is not a directory, will download the file every time and replace the file if the contents change. If C(no), the file will only be downloaded if the destination does not exist. Generally should be C(yes) only for small local files.
	// Prior to 0.6, this module behaved as if C(yes) was the default.
	//
	// Default: no
	// Required: false
	Force bool `yaml:"force,omitempty" json:"force,omitempty" cty:"force"`

	// ForceBasicAuth
	// Force the sending of the Basic authentication header upon initial request.
	// httplib2, the library used by the uri module only sends authentication information when a webservice responds to an initial request with a 401 status. Since some basic auth services do not properly send a 401, logins will fail.
	//
	// Default: no
	// Required: false
	ForceBasicAuth bool `yaml:"force_basic_auth,omitempty" json:"force_basic_auth,omitempty" cty:"force_basic_auth"`

	// Headers
	// Add custom HTTP headers to a request in hash/dict format.
	// The hash/dict format was added in Ansible 2.6.
	// Previous versions used a C("key:value,key:value") string format.
	// The C("key:value,key:value") string format is deprecated and has been removed in version 2.10.
	//
	// Default: <no value>
	// Required: false
	Headers map[string]string `yaml:"headers,omitempty" json:"headers,omitempty" cty:"headers"`

	// HttpAgent
	// Header to identify as, generally appears in web server logs.
	//
	// Default: ansible-httpget
	// Required: false
	HttpAgent string `yaml:"http_agent,omitempty" json:"http_agent,omitempty" cty:"http_agent"`

	// Sha256sum
	// If a SHA-256 checksum is passed to this parameter, the digest of the destination file will be calculated after it is downloaded to ensure its integrity and verify that the transfer completed successfully. This option is deprecated and will be removed in version 2.14. Use option C(checksum) instead.
	//
	// Default:
	// Required: false
	Sha256sum string `yaml:"sha256sum,omitempty" json:"sha256sum,omitempty" cty:"sha256sum"`

	// Timeout
	// Timeout in seconds for URL request.
	//
	// Default: 10
	// Required: false
	Timeout int `yaml:"timeout,omitempty" json:"timeout,omitempty" cty:"timeout"`

	// TmpDest
	// Absolute path of where temporary file is downloaded to.
	// When run on Ansible 2.5 or greater, path defaults to ansible's remote_tmp setting
	// When run on Ansible prior to 2.5, it defaults to C(TMPDIR), C(TEMP) or C(TMP) env variables or a platform specific value.
	// U(https://docs.python.org/3/library/tempfile.html#tempfile.tempdir)
	//
	// Default: <no value>
	// Required: false
	TmpDest string `yaml:"tmp_dest,omitempty" json:"tmp_dest,omitempty" cty:"tmp_dest"`

	// UnredirectedHeaders
	// A list of header names that will not be sent on subsequent redirected requests. This list is case insensitive. By default all headers will be redirected. In some cases it may be beneficial to list headers such as C(Authorization) here to avoid potential credential exposure.
	//
	// Default: []
	// Required: false
	UnredirectedHeaders []string `yaml:"unredirected_headers,omitempty" json:"unredirected_headers,omitempty" cty:"unredirected_headers"`

	// Url
	// HTTP, HTTPS, or FTP URL in the form (http|https|ftp)://[user[:pass]]@host.domain[:port]/path
	//
	// Default: <no value>
	// Required: true
	Url string `yaml:"url,omitempty" json:"url,omitempty" cty:"url"`

	// UrlPassword
	// The password for use in HTTP basic authentication.
	// If the C(url_username) parameter is not specified, the C(url_password) parameter will not be used.
	// Since version 2.8 you can also use the 'password' alias for this option.
	//
	// Default: <no value>
	// Required: false
	UrlPassword string `yaml:"url_password,omitempty" json:"url_password,omitempty" cty:"url_password"`

	// UrlUsername
	// The username for use in HTTP basic authentication.
	// This parameter can be used without C(url_password) for sites that allow empty passwords.
	// Since version 2.8 you can also use the C(username) alias for this option.
	//
	// Default: <no value>
	// Required: false
	UrlUsername string `yaml:"url_username,omitempty" json:"url_username,omitempty" cty:"url_username"`

	// UseGssapi
	// Use GSSAPI to perform the authentication, typically this is for Kerberos or Kerberos through Negotiate authentication.
	// Requires the Python library L(gssapi,https://github.com/pythongssapi/python-gssapi) to be installed.
	// Credentials for GSSAPI can be specified with I(url_username)/I(url_password) or with the GSSAPI env var C(KRB5CCNAME) that specified a custom Kerberos credential cache.
	// NTLM authentication is I(not) supported even if the GSSAPI mech for NTLM has been installed.
	//
	// Default: no
	// Required: false
	UseGssapi bool `yaml:"use_gssapi,omitempty" json:"use_gssapi,omitempty" cty:"use_gssapi"`

	// UseProxy
	// if C(no), it will not use a proxy, even if one is defined in an environment variable on the target hosts.
	//
	// Default: yes
	// Required: false
	UseProxy bool `yaml:"use_proxy,omitempty" json:"use_proxy,omitempty" cty:"use_proxy"`

	// ValidateCerts
	// If C(no), SSL certificates will not be validated.
	// This should only be used on personally controlled sites using self-signed certificates.
	//
	// Default: yes
	// Required: false
	ValidateCerts bool `yaml:"validate_certs,omitempty" json:"validate_certs,omitempty" cty:"validate_certs"`
	// contains filtered or unexported fields
}

type GetUrlResult struct {
	types.CommonReturn
	Raw string

	// BackupFile
	// name of backup file created after download
	BackupFile string `yaml:"backup_file,omitempty" json:"backup_file,omitempty" cty:"backup_file"`

	// ChecksumDest
	// sha1 checksum of the file after copy
	ChecksumDest string `yaml:"checksum_dest,omitempty" json:"checksum_dest,omitempty" cty:"checksum_dest"`

	// ChecksumSrc
	// sha1 checksum of the file
	ChecksumSrc string `yaml:"checksum_src,omitempty" json:"checksum_src,omitempty" cty:"checksum_src"`

	// Dest
	// destination file/path
	Dest string `yaml:"dest,omitempty" json:"dest,omitempty" cty:"dest"`

	// Elapsed
	// The number of seconds that elapsed while performing the download
	Elapsed int `yaml:"elapsed,omitempty" json:"elapsed,omitempty" cty:"elapsed"`

	// Gid
	// group id of the file
	Gid int `yaml:"gid,omitempty" json:"gid,omitempty" cty:"gid"`

	// Group
	// group of the file
	Group string `yaml:"group,omitempty" json:"group,omitempty" cty:"group"`

	// Md5sum
	// md5 checksum of the file after download
	Md5sum string `yaml:"md5sum,omitempty" json:"md5sum,omitempty" cty:"md5sum"`

	// Mode
	// permissions of the target
	Mode string `yaml:"mode,omitempty" json:"mode,omitempty" cty:"mode"`

	// Msg
	// the HTTP message from the request
	Msg string `yaml:"msg,omitempty" json:"msg,omitempty" cty:"msg"`

	// Owner
	// owner of the file
	Owner string `yaml:"owner,omitempty" json:"owner,omitempty" cty:"owner"`

	// Secontext
	// the SELinux security context of the file
	Secontext string `yaml:"secontext,omitempty" json:"secontext,omitempty" cty:"secontext"`

	// Size
	// size of the target
	Size int `yaml:"size,omitempty" json:"size,omitempty" cty:"size"`

	// Src
	// source file used after download
	Src string `yaml:"src,omitempty" json:"src,omitempty" cty:"src"`

	// State
	// state of the target
	State string `yaml:"state,omitempty" json:"state,omitempty" cty:"state"`

	// StatusCode
	// the HTTP status code from the request
	StatusCode int `yaml:"status_code,omitempty" json:"status_code,omitempty" cty:"status_code"`

	// Uid
	// owner id of the file, after execution
	Uid int `yaml:"uid,omitempty" json:"uid,omitempty" cty:"uid"`

	// Url
	// the actual URL used for the request
	Url string `yaml:"url,omitempty" json:"url,omitempty" cty:"url"`
	// contains filtered or unexported fields
}

type Getent struct {
	Params GetentParams
	Result GetentResult
}

type GetentParams struct {

	// Database
	// The name of a getent database supported by the target system (passwd, group, hosts, etc).
	//
	// Default: <no value>
	// Required: true
	Database string `yaml:"database,omitempty" json:"database,omitempty" cty:"database"`

	// FailKey
	// If a supplied key is missing this will make the task fail if C(yes).
	//
	// Default: yes
	// Required: false
	FailKey bool `yaml:"fail_key,omitempty" json:"fail_key,omitempty" cty:"fail_key"`

	// Key
	// Key from which to return values from the specified database, otherwise the full contents are returned.
	//
	// Default:
	// Required: false
	Key string `yaml:"key,omitempty" json:"key,omitempty" cty:"key"`

	// Service
	// Override all databases with the specified service
	// The underlying system must support the service flag which is not always available.
	//
	// Default: <no value>
	// Required: false
	Service string `yaml:"service,omitempty" json:"service,omitempty" cty:"service"`

	// Split
	// Character used to split the database values into lists/arrays such as ':' or '	', otherwise  it will try to pick one depending on the database.
	//
	// Default: <no value>
	// Required: false
	Split string `yaml:"split,omitempty" json:"split,omitempty" cty:"split"`
	// contains filtered or unexported fields
}

type GetentResult struct {
	types.CommonReturn
	Raw string

	// AnsibleFacts
	// Facts to add to ansible_facts.
	AnsibleFacts map[string]string `yaml:"ansible_facts,omitempty" json:"ansible_facts,omitempty" cty:"ansible_facts"`
	// contains filtered or unexported fields
}

type Git struct {
	Params GitParams
	Result GitResult
}

type GitParams struct {

	// AcceptHostkey
	// Will ensure or not that "-o StrictHostKeyChecking=no" is present as an ssh option.
	// Be aware that this disables a protection against MITM attacks.
	// Those using OpenSSH >= 7.5 might want to set I(ssh_opt) to 'StrictHostKeyChecking=accept-new' instead, it does not remove the MITM issue but it does restrict it to the first attempt.
	//
	// Default: no
	// Required: false
	AcceptHostkey bool `yaml:"accept_hostkey,omitempty" json:"accept_hostkey,omitempty" cty:"accept_hostkey"`

	// AcceptNewhostkey
	// As of OpenSSH 7.5, "-o StrictHostKeyChecking=accept-new" can be used which is safer and will only accepts host keys which are not present or are the same. if C(yes), ensure that "-o StrictHostKeyChecking=accept-new" is present as an ssh option.
	//
	// Default: no
	// Required: false
	AcceptNewhostkey bool `yaml:"accept_newhostkey,omitempty" json:"accept_newhostkey,omitempty" cty:"accept_newhostkey"`

	// Archive
	// Specify archive file path with extension. If specified, creates an archive file of the specified format containing the tree structure for the source tree. Allowed archive formats ["zip", "tar.gz", "tar", "tgz"].
	// This will clone and perform git archive from local directory as not all git servers support git archive.
	//
	// Default: <no value>
	// Required: false
	Archive string `yaml:"archive,omitempty" json:"archive,omitempty" cty:"archive"`

	// ArchivePrefix
	// Specify a prefix to add to each file path in archive. Requires I(archive) to be specified.
	//
	// Default: <no value>
	// Required: false
	ArchivePrefix string `yaml:"archive_prefix,omitempty" json:"archive_prefix,omitempty" cty:"archive_prefix"`

	// Bare
	// If C(yes), repository will be created as a bare repo, otherwise it will be a standard repo with a workspace.
	//
	// Default: no
	// Required: false
	Bare bool `yaml:"bare,omitempty" json:"bare,omitempty" cty:"bare"`

	// Clone
	// If C(no), do not clone the repository even if it does not exist locally.
	//
	// Default: yes
	// Required: false
	Clone bool `yaml:"clone,omitempty" json:"clone,omitempty" cty:"clone"`

	// Depth
	// Create a shallow clone with a history truncated to the specified number or revisions. The minimum possible value is C(1), otherwise ignored. Needs I(git>=1.9.1) to work correctly.
	//
	// Default: <no value>
	// Required: false
	Depth int `yaml:"depth,omitempty" json:"depth,omitempty" cty:"depth"`

	// Dest
	// The path of where the repository should be checked out. This is equivalent to C(git clone [repo_url] [directory]). The repository named in I(repo) is not appended to this path and the destination directory must be empty. This parameter is required, unless I(clone) is set to C(no).
	//
	// Default: <no value>
	// Required: true
	Dest string `yaml:"dest,omitempty" json:"dest,omitempty" cty:"dest"`

	// Executable
	// Path to git executable to use. If not supplied, the normal mechanism for resolving binary paths will be used.
	//
	// Default: <no value>
	// Required: false
	Executable string `yaml:"executable,omitempty" json:"executable,omitempty" cty:"executable"`

	// Force
	// If C(yes), any modified files in the working repository will be discarded.  Prior to 0.7, this was always C(yes) and could not be disabled.  Prior to 1.9, the default was C(yes).
	//
	// Default: no
	// Required: false
	Force bool `yaml:"force,omitempty" json:"force,omitempty" cty:"force"`

	// GpgWhitelist
	// A list of trusted GPG fingerprints to compare to the fingerprint of the GPG-signed commit.
	// Only used when I(verify_commit=yes).
	// Use of this feature requires Git 2.6+ due to its reliance on git's C(--raw) flag to C(verify-commit) and C(verify-tag).
	//
	// Default: []
	// Required: false
	GpgWhitelist []string `yaml:"gpg_whitelist,omitempty" json:"gpg_whitelist,omitempty" cty:"gpg_whitelist"`

	// KeyFile
	// Specify an optional private key file path, on the target host, to use for the checkout.
	// This ensures 'IdentitiesOnly=yes' is present in ssh_opts.
	//
	// Default: <no value>
	// Required: false
	KeyFile string `yaml:"key_file,omitempty" json:"key_file,omitempty" cty:"key_file"`

	// Recursive
	// If C(no), repository will be cloned without the --recursive option, skipping sub-modules.
	//
	// Default: yes
	// Required: false
	Recursive bool `yaml:"recursive,omitempty" json:"recursive,omitempty" cty:"recursive"`

	// Reference
	// Reference repository (see "git clone --reference ...").
	//
	// Default: <no value>
	// Required: false
	Reference string `yaml:"reference,omitempty" json:"reference,omitempty" cty:"reference"`

	// Refspec
	// Add an additional refspec to be fetched. If version is set to a I(SHA-1) not reachable from any branch or tag, this option may be necessary to specify the ref containing the I(SHA-1). Uses the same syntax as the C(git fetch) command. An example value could be "refs/meta/config".
	//
	// Default: <no value>
	// Required: false
	Refspec string `yaml:"refspec,omitempty" json:"refspec,omitempty" cty:"refspec"`

	// Remote
	// Name of the remote.
	//
	// Default: origin
	// Required: false
	Remote string `yaml:"remote,omitempty" json:"remote,omitempty" cty:"remote"`

	// Repo
	// git, SSH, or HTTP(S) protocol address of the git repository.
	//
	// Default: <no value>
	// Required: true
	Repo string `yaml:"repo,omitempty" json:"repo,omitempty" cty:"repo"`

	// SeparateGitDir
	// The path to place the cloned repository. If specified, Git repository can be separated from working tree.
	//
	// Default: <no value>
	// Required: false
	SeparateGitDir string `yaml:"separate_git_dir,omitempty" json:"separate_git_dir,omitempty" cty:"separate_git_dir"`

	// SingleBranch
	// Clone only the history leading to the tip of the specified revision.
	//
	// Default: no
	// Required: false
	SingleBranch bool `yaml:"single_branch,omitempty" json:"single_branch,omitempty" cty:"single_branch"`

	// SshOpts
	// Options git will pass to ssh when used as protocol, it works via C(git)'s GIT_SSH/GIT_SSH_COMMAND environment variables.
	// For older versions it appends GIT_SSH_OPTS (specific to this module) to the variables above or via a wrapper script.
	// Other options can add to this list, like I(key_file) and I(accept_hostkey).
	// An example value could be "-o StrictHostKeyChecking=no" (although this particular option is better set by I(accept_hostkey)).
	// The module ensures that 'BatchMode=yes' is always present to avoid prompts.
	//
	// Default: <no value>
	// Required: false
	SshOpts string `yaml:"ssh_opts,omitempty" json:"ssh_opts,omitempty" cty:"ssh_opts"`

	// TrackSubmodules
	// If C(yes), submodules will track the latest commit on their master branch (or other branch specified in .gitmodules).  If C(no), submodules will be kept at the revision specified by the main project. This is equivalent to specifying the --remote flag to git submodule update.
	//
	// Default: no
	// Required: false
	TrackSubmodules bool `yaml:"track_submodules,omitempty" json:"track_submodules,omitempty" cty:"track_submodules"`

	// Umask
	// The umask to set before doing any checkouts, or any other repository maintenance.
	//
	// Default: <no value>
	// Required: false
	Umask string `yaml:"umask,omitempty" json:"umask,omitempty" cty:"umask"`

	// Update
	// If C(no), do not retrieve new revisions from the origin repository.
	// Operations like archive will work on the existing (old) repository and might not respond to changes to the options version or remote.
	//
	// Default: yes
	// Required: false
	Update bool `yaml:"update,omitempty" json:"update,omitempty" cty:"update"`

	// VerifyCommit
	// If C(yes), when cloning or checking out a I(version) verify the signature of a GPG signed commit. This requires git version>=2.1.0 to be installed. The commit MUST be signed and the public key MUST be present in the GPG keyring.
	//
	// Default: no
	// Required: false
	VerifyCommit bool `yaml:"verify_commit,omitempty" json:"verify_commit,omitempty" cty:"verify_commit"`

	// Version
	// What version of the repository to check out. This can be the literal string C(HEAD), a branch name, a tag name. It can also be a I(SHA-1) hash, in which case I(refspec) needs to be specified if the given revision is not already available.
	//
	// Default: HEAD
	// Required: false
	Version string `yaml:"version,omitempty" json:"version,omitempty" cty:"version"`
	// contains filtered or unexported fields
}

type GitResult struct {
	types.CommonReturn
	Raw string

	// After
	// Last commit revision of the repository retrieved during the update.
	After string `yaml:"after,omitempty" json:"after,omitempty" cty:"after"`

	// Before
	// Commit revision before the repository was updated, "null" for new repository.
	Before string `yaml:"before,omitempty" json:"before,omitempty" cty:"before"`

	// GitDirBefore
	// Contains the original path of .git directory if it is changed.
	GitDirBefore string `yaml:"git_dir_before,omitempty" json:"git_dir_before,omitempty" cty:"git_dir_before"`

	// GitDirNow
	// Contains the new path of .git directory if it is changed.
	GitDirNow string `yaml:"git_dir_now,omitempty" json:"git_dir_now,omitempty" cty:"git_dir_now"`

	// RemoteUrlChanged
	// Contains True or False whether or not the remote URL was changed.
	RemoteUrlChanged bool `yaml:"remote_url_changed,omitempty" json:"remote_url_changed,omitempty" cty:"remote_url_changed"`

	// Warnings
	// List of warnings if requested features were not available due to a too old git version.
	Warnings string `yaml:"warnings,omitempty" json:"warnings,omitempty" cty:"warnings"`
	// contains filtered or unexported fields
}

type Group struct {
	Params GroupParams
	Result GroupResult
}

type GroupParams struct {

	// Gid
	// Optional I(GID) to set for the group.
	//
	// Default: <no value>
	// Required: false
	Gid int `yaml:"gid,omitempty" json:"gid,omitempty" cty:"gid"`

	// Local
	// Forces the use of "local" command alternatives on platforms that implement it.
	// This is useful in environments that use centralized authentication when you want to manipulate the local groups. (for example, it uses C(lgroupadd) instead of C(groupadd)).
	// This requires that these commands exist on the targeted host, otherwise it will be a fatal error.
	//
	// Default: no
	// Required: false
	Local bool `yaml:"local,omitempty" json:"local,omitempty" cty:"local"`

	// Name
	// Name of the group to manage.
	//
	// Default: <no value>
	// Required: true
	Name string `yaml:"name,omitempty" json:"name,omitempty" cty:"name"`

	// NonUnique
	// This option allows to change the group ID to a non-unique value. Requires C(gid).
	// Not supported on macOS or BusyBox distributions.
	//
	// Default: no
	// Required: false
	NonUnique bool `yaml:"non_unique,omitempty" json:"non_unique,omitempty" cty:"non_unique"`

	// State
	// Whether the group should be present or not on the remote host.
	//
	// Default: present
	// Required: false
	State string `yaml:"state,omitempty" json:"state,omitempty" cty:"state"`

	// System
	// If I(yes), indicates that the group created is a system group.
	//
	// Default: no
	// Required: false
	System bool `yaml:"system,omitempty" json:"system,omitempty" cty:"system"`
	// contains filtered or unexported fields
}

type GroupResult struct {
	types.CommonReturn
	Raw string

	// Gid
	// Group ID of the group.
	Gid int `yaml:"gid,omitempty" json:"gid,omitempty" cty:"gid"`

	// Name
	// Group name.
	Name string `yaml:"name,omitempty" json:"name,omitempty" cty:"name"`

	// State
	// Whether the group is present or not.
	State string `yaml:"state,omitempty" json:"state,omitempty" cty:"state"`

	// System
	// Whether the group is a system group or not.
	System bool `yaml:"system,omitempty" json:"system,omitempty" cty:"system"`
	// contains filtered or unexported fields
}

type Hostname struct {
	Params HostnameParams
	Result HostnameResult
}

type HostnameParams struct {

	// Name
	// Name of the host.
	// If the value is a fully qualified domain name that does not resolve from the given host, this will cause the module to hang for a few seconds while waiting for the name resolution attempt to timeout.
	//
	// Default: <no value>
	// Required: true
	Name string `yaml:"name,omitempty" json:"name,omitempty" cty:"name"`

	// Use
	// Which strategy to use to update the hostname.
	// If not set we try to autodetect, but this can be problematic, particularly with containers as they can present misleading information.
	// Note that 'systemd' should be specified for RHEL/EL/CentOS 7+. Older distributions should use 'redhat'.
	//
	// Default: <no value>
	// Required: false
	Use string `yaml:"use,omitempty" json:"use,omitempty" cty:"use"`
	// contains filtered or unexported fields
}

type HostnameResult struct {
	types.CommonReturn
	Raw string
	// contains filtered or unexported fields
}

type Iptables struct {
	Params IptablesParams
	Result IptablesResult
}

type IptablesParams struct {

	// Action
	// Whether the rule should be appended at the bottom or inserted at the top.
	// If the rule already exists the chain will not be modified.
	//
	// Default: append
	// Required: false
	Action string `yaml:"action,omitempty" json:"action,omitempty" cty:"action"`

	// Chain
	// Specify the iptables chain to modify.
	// This could be a user-defined chain or one of the standard iptables chains, like C(INPUT), C(FORWARD), C(OUTPUT), C(PREROUTING), C(POSTROUTING), C(SECMARK) or C(CONNSECMARK).
	//
	// Default: <no value>
	// Required: false
	Chain string `yaml:"chain,omitempty" json:"chain,omitempty" cty:"chain"`

	// ChainManagement
	// If C(true) and C(state) is C(present), the chain will be created if needed.
	// If C(true) and C(state) is C(absent), the chain will be deleted if the only other parameter passed are C(chain) and optionally C(table).
	//
	// Default: false
	// Required: false
	ChainManagement bool `yaml:"chain_management,omitempty" json:"chain_management,omitempty" cty:"chain_management"`

	// Comment
	// This specifies a comment that will be added to the rule.
	//
	// Default: <no value>
	// Required: false
	Comment string `yaml:"comment,omitempty" json:"comment,omitempty" cty:"comment"`

	// Ctstate
	// A list of the connection states to match in the conntrack module.
	// Possible values are C(INVALID), C(NEW), C(ESTABLISHED), C(RELATED), C(UNTRACKED), C(SNAT), C(DNAT).
	//
	// Default: []
	// Required: false
	Ctstate []string `yaml:"ctstate,omitempty" json:"ctstate,omitempty" cty:"ctstate"`

	// Destination
	// Destination specification.
	// Address can be either a network name, a hostname, a network IP address (with /mask), or a plain IP address.
	// Hostnames will be resolved once only, before the rule is submitted to the kernel. Please note that specifying any name to be resolved with a remote query such as DNS is a really bad idea.
	// The mask can be either a network mask or a plain number, specifying the number of 1's at the left side of the network mask. Thus, a mask of 24 is equivalent to 255.255.255.0. A C(!) argument before the address specification inverts the sense of the address.
	//
	// Default: <no value>
	// Required: false
	Destination string `yaml:"destination,omitempty" json:"destination,omitempty" cty:"destination"`

	// DestinationPort
	// Destination port or port range specification. This can either be a service name or a port number. An inclusive range can also be specified, using the format first:last. If the first port is omitted, '0' is assumed; if the last is omitted, '65535' is assumed. If the first port is greater than the second one they will be swapped. This is only valid if the rule also specifies one of the following protocols: tcp, udp, dccp or sctp.
	//
	// Default: <no value>
	// Required: false
	DestinationPort string `yaml:"destination_port,omitempty" json:"destination_port,omitempty" cty:"destination_port"`

	// DestinationPorts
	// This specifies multiple destination port numbers or port ranges to match in the multiport module.
	// It can only be used in conjunction with the protocols tcp, udp, udplite, dccp and sctp.
	//
	// Default: <no value>
	// Required: false
	DestinationPorts []string `yaml:"destination_ports,omitempty" json:"destination_ports,omitempty" cty:"destination_ports"`

	// DstRange
	// Specifies the destination IP range to match in the iprange module.
	//
	// Default: <no value>
	// Required: false
	DstRange string `yaml:"dst_range,omitempty" json:"dst_range,omitempty" cty:"dst_range"`

	// Flush
	// Flushes the specified table and chain of all rules.
	// If no chain is specified then the entire table is purged.
	// Ignores all other parameters.
	//
	// Default: false
	// Required: false
	Flush bool `yaml:"flush,omitempty" json:"flush,omitempty" cty:"flush"`

	// Fragment
	// This means that the rule only refers to second and further fragments of fragmented packets.
	// Since there is no way to tell the source or destination ports of such a packet (or ICMP type), such a packet will not match any rules which specify them.
	// When the "!" argument precedes fragment argument, the rule will only match head fragments, or unfragmented packets.
	//
	// Default: <no value>
	// Required: false
	Fragment string `yaml:"fragment,omitempty" json:"fragment,omitempty" cty:"fragment"`

	// Gateway
	// This specifies the IP address of host to send the cloned packets.
	// This option is only valid when C(jump) is set to C(TEE).
	//
	// Default: <no value>
	// Required: false
	Gateway string `yaml:"gateway,omitempty" json:"gateway,omitempty" cty:"gateway"`

	// GidOwner
	// Specifies the GID or group to use in match by owner rule.
	//
	// Default: <no value>
	// Required: false
	GidOwner string `yaml:"gid_owner,omitempty" json:"gid_owner,omitempty" cty:"gid_owner"`

	// Goto
	// This specifies that the processing should continue in a user specified chain.
	// Unlike the jump argument return will not continue processing in this chain but instead in the chain that called us via jump.
	//
	// Default: <no value>
	// Required: false
	Goto string `yaml:"goto,omitempty" json:"goto,omitempty" cty:"goto"`

	// IcmpType
	// This allows specification of the ICMP type, which can be a numeric ICMP type, type/code pair, or one of the ICMP type names shown by the command 'iptables -p icmp -h'
	//
	// Default: <no value>
	// Required: false
	IcmpType string `yaml:"icmp_type,omitempty" json:"icmp_type,omitempty" cty:"icmp_type"`

	// InInterface
	// Name of an interface via which a packet was received (only for packets entering the C(INPUT), C(FORWARD) and C(PREROUTING) chains).
	// When the C(!) argument is used before the interface name, the sense is inverted.
	// If the interface name ends in a C(+), then any interface which begins with this name will match.
	// If this option is omitted, any interface name will match.
	//
	// Default: <no value>
	// Required: false
	InInterface string `yaml:"in_interface,omitempty" json:"in_interface,omitempty" cty:"in_interface"`

	// IpVersion
	// Which version of the IP protocol this rule should apply to.
	//
	// Default: ipv4
	// Required: false
	IpVersion string `yaml:"ip_version,omitempty" json:"ip_version,omitempty" cty:"ip_version"`

	// Jump
	// This specifies the target of the rule; i.e., what to do if the packet matches it.
	// The target can be a user-defined chain (other than the one this rule is in), one of the special builtin targets which decide the fate of the packet immediately, or an extension (see EXTENSIONS below).
	// If this option is omitted in a rule (and the goto parameter is not used), then matching the rule will have no effect on the packet's fate, but the counters on the rule will be incremented.
	//
	// Default: <no value>
	// Required: false
	Jump string `yaml:"jump,omitempty" json:"jump,omitempty" cty:"jump"`

	// Limit
	// Specifies the maximum average number of matches to allow per second.
	// The number can specify units explicitly, using C(/second), C(/minute), C(/hour) or C(/day), or parts of them (so C(5/second) is the same as C(5/s)).
	//
	// Default: <no value>
	// Required: false
	Limit string `yaml:"limit,omitempty" json:"limit,omitempty" cty:"limit"`

	// LimitBurst
	// Specifies the maximum burst before the above limit kicks in.
	//
	// Default: <no value>
	// Required: false
	LimitBurst string `yaml:"limit_burst,omitempty" json:"limit_burst,omitempty" cty:"limit_burst"`

	// LogLevel
	// Logging level according to the syslogd-defined priorities.
	// The value can be strings or numbers from 1-8.
	// This parameter is only applicable if C(jump) is set to C(LOG).
	//
	// Default: <no value>
	// Required: false
	LogLevel string `yaml:"log_level,omitempty" json:"log_level,omitempty" cty:"log_level"`

	// LogPrefix
	// Specifies a log text for the rule. Only make sense with a LOG jump.
	//
	// Default: <no value>
	// Required: false
	LogPrefix string `yaml:"log_prefix,omitempty" json:"log_prefix,omitempty" cty:"log_prefix"`

	// Match
	// Specifies a match to use, that is, an extension module that tests for a specific property.
	// The set of matches make up the condition under which a target is invoked.
	// Matches are evaluated first to last if specified as an array and work in short-circuit fashion, i.e. if one extension yields false, evaluation will stop.
	//
	// Default: []
	// Required: false
	Match []string `yaml:"match,omitempty" json:"match,omitempty" cty:"match"`

	// MatchSet
	// Specifies a set name which can be defined by ipset.
	// Must be used together with the match_set_flags parameter.
	// When the C(!) argument is prepended then it inverts the rule.
	// Uses the iptables set extension.
	//
	// Default: <no value>
	// Required: false
	MatchSet string `yaml:"match_set,omitempty" json:"match_set,omitempty" cty:"match_set"`

	// MatchSetFlags
	// Specifies the necessary flags for the match_set parameter.
	// Must be used together with the match_set parameter.
	// Uses the iptables set extension.
	//
	// Default: <no value>
	// Required: false
	MatchSetFlags string `yaml:"match_set_flags,omitempty" json:"match_set_flags,omitempty" cty:"match_set_flags"`

	// OutInterface
	// Name of an interface via which a packet is going to be sent (for packets entering the C(FORWARD), C(OUTPUT) and C(POSTROUTING) chains).
	// When the C(!) argument is used before the interface name, the sense is inverted.
	// If the interface name ends in a C(+), then any interface which begins with this name will match.
	// If this option is omitted, any interface name will match.
	//
	// Default: <no value>
	// Required: false
	OutInterface string `yaml:"out_interface,omitempty" json:"out_interface,omitempty" cty:"out_interface"`

	// Policy
	// Set the policy for the chain to the given target.
	// Only built-in chains can have policies.
	// This parameter requires the C(chain) parameter.
	// If you specify this parameter, all other parameters will be ignored.
	// This parameter is used to set default policy for the given C(chain). Do not confuse this with C(jump) parameter.
	//
	// Default: <no value>
	// Required: false
	Policy string `yaml:"policy,omitempty" json:"policy,omitempty" cty:"policy"`

	// Protocol
	// The protocol of the rule or of the packet to check.
	// The specified protocol can be one of C(tcp), C(udp), C(udplite), C(icmp), C(ipv6-icmp) or C(icmpv6), C(esp), C(ah), C(sctp) or the special keyword C(all), or it can be a numeric value, representing one of these protocols or a different one.
	// A protocol name from I(/etc/protocols) is also allowed.
	// A C(!) argument before the protocol inverts the test.
	// The number zero is equivalent to all.
	// C(all) will match with all protocols and is taken as default when this option is omitted.
	//
	// Default: <no value>
	// Required: false
	Protocol string `yaml:"protocol,omitempty" json:"protocol,omitempty" cty:"protocol"`

	// RejectWith
	// Specifies the error packet type to return while rejecting. It implies "jump: REJECT".
	//
	// Default: <no value>
	// Required: false
	RejectWith string `yaml:"reject_with,omitempty" json:"reject_with,omitempty" cty:"reject_with"`

	// RuleNum
	// Insert the rule as the given rule number.
	// This works only with C(action=insert).
	//
	// Default: <no value>
	// Required: false
	RuleNum string `yaml:"rule_num,omitempty" json:"rule_num,omitempty" cty:"rule_num"`

	// SetCounters
	// This enables the administrator to initialize the packet and byte counters of a rule (during C(INSERT), C(APPEND), C(REPLACE) operations).
	//
	// Default: <no value>
	// Required: false
	SetCounters string `yaml:"set_counters,omitempty" json:"set_counters,omitempty" cty:"set_counters"`

	// SetDscpMark
	// This allows specifying a DSCP mark to be added to packets. It takes either an integer or hex value.
	// Mutually exclusive with C(set_dscp_mark_class).
	//
	// Default: <no value>
	// Required: false
	SetDscpMark string `yaml:"set_dscp_mark,omitempty" json:"set_dscp_mark,omitempty" cty:"set_dscp_mark"`

	// SetDscpMarkClass
	// This allows specifying a predefined DiffServ class which will be translated to the corresponding DSCP mark.
	// Mutually exclusive with C(set_dscp_mark).
	//
	// Default: <no value>
	// Required: false
	SetDscpMarkClass string `yaml:"set_dscp_mark_class,omitempty" json:"set_dscp_mark_class,omitempty" cty:"set_dscp_mark_class"`

	// Source
	// Source specification.
	// Address can be either a network name, a hostname, a network IP address (with /mask), or a plain IP address.
	// Hostnames will be resolved once only, before the rule is submitted to the kernel. Please note that specifying any name to be resolved with a remote query such as DNS is a really bad idea.
	// The mask can be either a network mask or a plain number, specifying the number of 1's at the left side of the network mask. Thus, a mask of 24 is equivalent to 255.255.255.0. A C(!) argument before the address specification inverts the sense of the address.
	//
	// Default: <no value>
	// Required: false
	Source string `yaml:"source,omitempty" json:"source,omitempty" cty:"source"`

	// SourcePort
	// Source port or port range specification.
	// This can either be a service name or a port number.
	// An inclusive range can also be specified, using the format C(first:last).
	// If the first port is omitted, C(0) is assumed; if the last is omitted, C(65535) is assumed.
	// If the first port is greater than the second one they will be swapped.
	//
	// Default: <no value>
	// Required: false
	SourcePort string `yaml:"source_port,omitempty" json:"source_port,omitempty" cty:"source_port"`

	// SrcRange
	// Specifies the source IP range to match in the iprange module.
	//
	// Default: <no value>
	// Required: false
	SrcRange string `yaml:"src_range,omitempty" json:"src_range,omitempty" cty:"src_range"`

	// State
	// Whether the rule should be absent or present.
	//
	// Default: present
	// Required: false
	State string `yaml:"state,omitempty" json:"state,omitempty" cty:"state"`

	// Syn
	// This allows matching packets that have the SYN bit set and the ACK and RST bits unset.
	// When negated, this matches all packets with the RST or the ACK bits set.
	//
	// Default: ignore
	// Required: false
	Syn string `yaml:"syn,omitempty" json:"syn,omitempty" cty:"syn"`

	// Table
	// This option specifies the packet matching table which the command should operate on.
	// If the kernel is configured with automatic module loading, an attempt will be made to load the appropriate module for that table if it is not already there.
	//
	// Default: filter
	// Required: false
	Table string `yaml:"table,omitempty" json:"table,omitempty" cty:"table"`

	// TcpFlags
	// TCP flags specification.
	// C(tcp_flags) expects a dict with the two keys C(flags) and C(flags_set).
	//
	// Default: map[]
	// Required: false
	TcpFlags map[string]string `yaml:"tcp_flags,omitempty" json:"tcp_flags,omitempty" cty:"tcp_flags"`

	// ToDestination
	// This specifies a destination address to use with C(DNAT).
	// Without this, the destination address is never altered.
	//
	// Default: <no value>
	// Required: false
	ToDestination string `yaml:"to_destination,omitempty" json:"to_destination,omitempty" cty:"to_destination"`

	// ToPorts
	// This specifies a destination port or range of ports to use, without this, the destination port is never altered.
	// This is only valid if the rule also specifies one of the protocol C(tcp), C(udp), C(dccp) or C(sctp).
	//
	// Default: <no value>
	// Required: false
	ToPorts string `yaml:"to_ports,omitempty" json:"to_ports,omitempty" cty:"to_ports"`

	// ToSource
	// This specifies a source address to use with C(SNAT).
	// Without this, the source address is never altered.
	//
	// Default: <no value>
	// Required: false
	ToSource string `yaml:"to_source,omitempty" json:"to_source,omitempty" cty:"to_source"`

	// UidOwner
	// Specifies the UID or username to use in match by owner rule.
	// From Ansible 2.6 when the C(!) argument is prepended then the it inverts the rule to apply instead to all users except that one specified.
	//
	// Default: <no value>
	// Required: false
	UidOwner string `yaml:"uid_owner,omitempty" json:"uid_owner,omitempty" cty:"uid_owner"`

	// Wait
	// Wait N seconds for the xtables lock to prevent multiple instances of the program from running concurrently.
	//
	// Default: <no value>
	// Required: false
	Wait string `yaml:"wait,omitempty" json:"wait,omitempty" cty:"wait"`
	// contains filtered or unexported fields
}

type IptablesResult struct {
	types.CommonReturn
	Raw string
	// contains filtered or unexported fields
}

type KnownHosts struct {
	Params KnownHostsParams
	Result KnownHostsResult
}

type KnownHostsParams struct {

	// HashHost
	// Hash the hostname in the known_hosts file.
	//
	// Default: no
	// Required: false
	HashHost bool `yaml:"hash_host,omitempty" json:"hash_host,omitempty" cty:"hash_host"`

	// Key
	// The SSH public host key, as a string.
	// Required if C(state=present), optional when C(state=absent), in which case all keys for the host are removed.
	// The key must be in the right format for SSH (see sshd(8), section "SSH_KNOWN_HOSTS FILE FORMAT").
	// Specifically, the key should not match the format that is found in an SSH pubkey file, but should rather have the hostname prepended to a line that includes the pubkey, the same way that it would appear in the known_hosts file. The value prepended to the line must also match the value of the name parameter.
	// Should be of format C(<hostname[,IP]> ssh-rsa <pubkey>).
	// For custom SSH port, C(key) needs to specify port as well. See example section.
	//
	// Default: <no value>
	// Required: false
	Key string `yaml:"key,omitempty" json:"key,omitempty" cty:"key"`

	// Name
	// The host to add or remove (must match a host specified in key). It will be converted to lowercase so that ssh-keygen can find it.
	// Must match with <hostname> or <ip> present in key attribute.
	// For custom SSH port, C(name) needs to specify port as well. See example section.
	//
	// Default: <no value>
	// Required: true
	Name string `yaml:"name,omitempty" json:"name,omitempty" cty:"name"`

	// Path
	// The known_hosts file to edit.
	// The known_hosts file will be created if needed. The rest of the path must exist prior to running the module.
	//
	// Default: ~/.ssh/known_hosts
	// Required: false
	Path string `yaml:"path,omitempty" json:"path,omitempty" cty:"path"`

	// State
	// I(present) to add the host key.
	// I(absent) to remove it.
	//
	// Default: present
	// Required: false
	State string `yaml:"state,omitempty" json:"state,omitempty" cty:"state"`
	// contains filtered or unexported fields
}

type KnownHostsResult struct {
	types.CommonReturn
	Raw string
	// contains filtered or unexported fields
}

type Lineinfile struct {
	Params LineinfileParams
	Result LineinfileResult
}

type LineinfileParams struct {

	// Backrefs
	// Used with C(state=present).
	// If set, C(line) can contain backreferences (both positional and named) that will get populated if the C(regexp) matches.
	// This parameter changes the operation of the module slightly; C(insertbefore) and C(insertafter) will be ignored, and if the C(regexp) does not match anywhere in the file, the file will be left unchanged.
	// If the C(regexp) does match, the last matching line will be replaced by the expanded line parameter.
	// Mutually exclusive with C(search_string).
	//
	// Default: no
	// Required: false
	Backrefs bool `yaml:"backrefs,omitempty" json:"backrefs,omitempty" cty:"backrefs"`

	// Backup
	// Create a backup file including the timestamp information so you can get the original file back if you somehow clobbered it incorrectly.
	//
	// Default: no
	// Required: false
	Backup bool `yaml:"backup,omitempty" json:"backup,omitempty" cty:"backup"`

	// Create
	// Used with C(state=present).
	// If specified, the file will be created if it does not already exist.
	// By default it will fail if the file is missing.
	//
	// Default: no
	// Required: false
	Create bool `yaml:"create,omitempty" json:"create,omitempty" cty:"create"`

	// Firstmatch
	// Used with C(insertafter) or C(insertbefore).
	// If set, C(insertafter) and C(insertbefore) will work with the first line that matches the given regular expression.
	//
	// Default: no
	// Required: false
	Firstmatch bool `yaml:"firstmatch,omitempty" json:"firstmatch,omitempty" cty:"firstmatch"`

	// Insertafter
	// Used with C(state=present).
	// If specified, the line will be inserted after the last match of specified regular expression.
	// If the first match is required, use(firstmatch=yes).
	// A special value is available; C(EOF) for inserting the line at the end of the file.
	// If specified regular expression has no matches, EOF will be used instead.
	// If C(insertbefore) is set, default value C(EOF) will be ignored.
	// If regular expressions are passed to both C(regexp) and C(insertafter), C(insertafter) is only honored if no match for C(regexp) is found.
	// May not be used with C(backrefs) or C(insertbefore).
	//
	// Default: EOF
	// Required: false
	Insertafter string `yaml:"insertafter,omitempty" json:"insertafter,omitempty" cty:"insertafter"`

	// Insertbefore
	// Used with C(state=present).
	// If specified, the line will be inserted before the last match of specified regular expression.
	// If the first match is required, use C(firstmatch=yes).
	// A value is available; C(BOF) for inserting the line at the beginning of the file.
	// If specified regular expression has no matches, the line will be inserted at the end of the file.
	// If regular expressions are passed to both C(regexp) and C(insertbefore), C(insertbefore) is only honored if no match for C(regexp) is found.
	// May not be used with C(backrefs) or C(insertafter).
	//
	// Default: <no value>
	// Required: false
	Insertbefore string `yaml:"insertbefore,omitempty" json:"insertbefore,omitempty" cty:"insertbefore"`

	// Line
	// The line to insert/replace into the file.
	// Required for C(state=present).
	// If C(backrefs) is set, may contain backreferences that will get expanded with the C(regexp) capture groups if the regexp matches.
	//
	// Default: <no value>
	// Required: false
	Line string `yaml:"line,omitempty" json:"line,omitempty" cty:"line"`

	// Others
	// All arguments accepted by the M(ansible.builtin.file) module also work here.
	//
	// Default: <no value>
	// Required: false
	Others string `yaml:"others,omitempty" json:"others,omitempty" cty:"others"`

	// Path
	// The file to modify.
	// Before Ansible 2.3 this option was only usable as I(dest), I(destfile) and I(name).
	//
	// Default: <no value>
	// Required: true
	Path string `yaml:"path,omitempty" json:"path,omitempty" cty:"path"`

	// Regexp
	// The regular expression to look for in every line of the file.
	// For C(state=present), the pattern to replace if found. Only the last line found will be replaced.
	// For C(state=absent), the pattern of the line(s) to remove.
	// If the regular expression is not matched, the line will be added to the file in keeping with C(insertbefore) or C(insertafter) settings.
	// When modifying a line the regexp should typically match both the initial state of the line as well as its state after replacement by C(line) to ensure idempotence.
	// Uses Python regular expressions. See U(https://docs.python.org/3/library/re.html).
	//
	// Default: <no value>
	// Required: false
	Regexp string `yaml:"regexp,omitempty" json:"regexp,omitempty" cty:"regexp"`

	// SearchString
	// The literal string to look for in every line of the file. This does not have to match the entire line.
	// For C(state=present), the line to replace if the string is found in the file. Only the last line found will be replaced.
	// For C(state=absent), the line(s) to remove if the string is in the line.
	// If the literal expression is not matched, the line will be added to the file in keeping with C(insertbefore) or C(insertafter) settings.
	// Mutually exclusive with C(backrefs) and C(regexp).
	//
	// Default: <no value>
	// Required: false
	SearchString string `yaml:"search_string,omitempty" json:"search_string,omitempty" cty:"search_string"`

	// State
	// Whether the line should be there or not.
	//
	// Default: present
	// Required: false
	State string `yaml:"state,omitempty" json:"state,omitempty" cty:"state"`
	// contains filtered or unexported fields
}