diff options
Diffstat (limited to 'internal/config/helpers.gen.go')
| -rw-r--r-- | internal/config/helpers.gen.go | 3962 |
1 files changed, 3295 insertions, 667 deletions
diff --git a/internal/config/helpers.gen.go b/internal/config/helpers.gen.go index 2fa502084..5ca6a69e7 100644 --- a/internal/config/helpers.gen.go +++ b/internal/config/helpers.gen.go @@ -19,12 +19,1862 @@ package config import ( + "fmt" "time" "code.superseriousbusiness.org/gotosocial/internal/language" "codeberg.org/gruf/go-bytesize" + "github.com/spf13/cast" + "github.com/spf13/pflag" ) +func (cfg *Configuration) RegisterFlags(flags *pflag.FlagSet) { + flags.String("log-level", cfg.LogLevel, "Log level to run at: [trace, debug, info, warn, fatal]") + flags.String("log-timestamp-format", cfg.LogTimestampFormat, "Format to use for the log timestamp, as supported by Go's time.Layout") + flags.Bool("log-db-queries", cfg.LogDbQueries, "Log database queries verbosely when log-level is trace or debug") + flags.Bool("log-client-ip", cfg.LogClientIP, "Include the client IP in logs") + flags.String("request-id-header", cfg.RequestIDHeader, "Header to extract the Request ID from. Eg.,'X-Request-Id'.") + flags.String("config-path", cfg.ConfigPath, "Path to a file containing gotosocial configuration. Values set in this file will be overwritten by values set as env vars or arguments") + flags.String("application-name", cfg.ApplicationName, "Name of the application, used in various places internally") + flags.String("landing-page-user", cfg.LandingPageUser, "the user that should be shown on the instance's landing page") + flags.String("host", cfg.Host, "Hostname to use for the server (eg., example.org, gotosocial.whatever.com). DO NOT change this on a server that's already run!") + flags.String("account-domain", cfg.AccountDomain, "Domain to use in account names (eg., example.org, whatever.com). If not set, will default to the setting for host. DO NOT change this on a server that's already run!") + flags.String("protocol", cfg.Protocol, "Protocol to use for the REST api of the server (only use http if you are debugging or behind a reverse proxy!)") + flags.String("bind-address", cfg.BindAddress, "Bind address to use for the GoToSocial server (eg., 0.0.0.0, 172.138.0.9, [::], localhost). For ipv6, enclose the address in square brackets, eg [2001:db8::fed1]. Default binds to all interfaces.") + flags.Int("port", cfg.Port, "Port to use for GoToSocial. Change this to 443 if you're running the binary directly on the host machine.") + flags.StringSlice("trusted-proxies", cfg.TrustedProxies, "Proxies to trust when parsing x-forwarded headers into real IPs.") + flags.String("software-version", cfg.SoftwareVersion, "") + flags.String("db-type", cfg.DbType, "Database type: eg., postgres") + flags.String("db-address", cfg.DbAddress, "Database ipv4 address, hostname, or filename") + flags.Int("db-port", cfg.DbPort, "Database port") + flags.String("db-user", cfg.DbUser, "Database username") + flags.String("db-password", cfg.DbPassword, "Database password") + flags.String("db-database", cfg.DbDatabase, "Database name") + flags.String("db-tls-mode", cfg.DbTLSMode, "Database tls mode") + flags.String("db-tls-ca-cert", cfg.DbTLSCACert, "Path to CA cert for db tls connection") + flags.Int("db-max-open-conns-multiplier", cfg.DbMaxOpenConnsMultiplier, "Multiplier to use per cpu for max open database connections. 0 or less is normalized to 1.") + flags.String("db-sqlite-journal-mode", cfg.DbSqliteJournalMode, "Sqlite only: see https://www.sqlite.org/pragma.html#pragma_journal_mode") + flags.String("db-sqlite-synchronous", cfg.DbSqliteSynchronous, "Sqlite only: see https://www.sqlite.org/pragma.html#pragma_synchronous") + flags.String("db-sqlite-cache-size", cfg.DbSqliteCacheSize.String(), "Sqlite only: see https://www.sqlite.org/pragma.html#pragma_cache_size") + flags.Duration("db-sqlite-busy-timeout", cfg.DbSqliteBusyTimeout, "Sqlite only: see https://www.sqlite.org/pragma.html#pragma_busy_timeout") + flags.String("db-postgres-connection-string", cfg.DbPostgresConnectionString, "Full Database URL for connection to postgres") + flags.String("web-template-base-dir", cfg.WebTemplateBaseDir, "Basedir for html templating files for rendering pages and composing emails.") + flags.String("web-asset-base-dir", cfg.WebAssetBaseDir, "Directory to serve static assets from, accessible at example.org/assets/") + flags.String("instance-federation-mode", cfg.InstanceFederationMode, "Set instance federation mode.") + flags.Bool("instance-federation-spam-filter", cfg.InstanceFederationSpamFilter, "Enable basic spam filter heuristics for messages coming from other instances, and drop messages identified as spam") + flags.Bool("instance-expose-peers", cfg.InstanceExposePeers, "Allow unauthenticated users to query /api/v1/instance/peers?filter=open") + flags.Bool("instance-expose-suspended", cfg.InstanceExposeSuspended, "Expose suspended instances via web UI, and allow unauthenticated users to query /api/v1/instance/peers?filter=suspended") + flags.Bool("instance-expose-suspended-web", cfg.InstanceExposeSuspendedWeb, "Expose list of suspended instances as webpage on /about/suspended") + flags.Bool("instance-expose-public-timeline", cfg.InstanceExposePublicTimeline, "Allow unauthenticated users to query /api/v1/timelines/public") + flags.Bool("instance-deliver-to-shared-inboxes", cfg.InstanceDeliverToSharedInboxes, "Deliver federated messages to shared inboxes, if they're available.") + flags.Bool("instance-inject-mastodon-version", cfg.InstanceInjectMastodonVersion, "This injects a Mastodon compatible version in /api/v1/instance to help Mastodon clients that use that version for feature detection") + flags.StringSlice("instance-languages", cfg.InstanceLanguages.Strings(), "BCP47 language tags for the instance. Used to indicate the preferred languages of instance residents (in order from most-preferred to least-preferred).") + flags.String("instance-subscriptions-process-from", cfg.InstanceSubscriptionsProcessFrom, "Time of day from which to start running instance subscriptions processing jobs. Should be in the format 'hh:mm:ss', eg., '15:04:05'.") + flags.Duration("instance-subscriptions-process-every", cfg.InstanceSubscriptionsProcessEvery, "Period to elapse between instance subscriptions processing jobs, starting from instance-subscriptions-process-from.") + flags.String("instance-stats-mode", cfg.InstanceStatsMode, "Allows you to customize the way stats are served to crawlers: one of '', 'serve', 'zero', 'baffle'. Home page stats remain unchanged.") + flags.Bool("instance-allow-backdating-statuses", cfg.InstanceAllowBackdatingStatuses, "Allow local accounts to backdate statuses using the scheduled_at param to /api/v1/statuses") + flags.Bool("accounts-registration-open", cfg.AccountsRegistrationOpen, "Allow anyone to submit an account signup request. If false, server will be invite-only.") + flags.Bool("accounts-reason-required", cfg.AccountsReasonRequired, "Do new account signups require a reason to be submitted on registration?") + flags.Int("accounts-registration-daily-limit", cfg.AccountsRegistrationDailyLimit, "Limit amount of approved account sign-ups allowed per 24hrs before registration is closed. 0 or less = no limit.") + flags.Int("accounts-registration-backlog-limit", cfg.AccountsRegistrationBacklogLimit, "Limit how big the 'accounts pending approval' queue can grow before registration is closed. 0 or less = no limit.") + flags.Bool("accounts-allow-custom-css", cfg.AccountsAllowCustomCSS, "Allow accounts to enable custom CSS for their profile pages and statuses.") + flags.Int("accounts-custom-css-length", cfg.AccountsCustomCSSLength, "Maximum permitted length (characters) of custom CSS for accounts.") + flags.Int("media-description-min-chars", cfg.MediaDescriptionMinChars, "Min required chars for an image description") + flags.Int("media-description-max-chars", cfg.MediaDescriptionMaxChars, "Max permitted chars for an image description") + flags.Int("media-remote-cache-days", cfg.MediaRemoteCacheDays, "Number of days to locally cache media from remote instances. If set to 0, remote media will be kept indefinitely.") + flags.String("media-emoji-local-max-size", cfg.MediaEmojiLocalMaxSize.String(), "Max size in bytes of emojis uploaded to this instance via the admin API.") + flags.String("media-emoji-remote-max-size", cfg.MediaEmojiRemoteMaxSize.String(), "Max size in bytes of emojis to download from other instances.") + flags.String("media-image-size-hint", cfg.MediaImageSizeHint.String(), "Size in bytes of max image size referred to on /api/v_/instance endpoints (else, local max size)") + flags.String("media-video-size-hint", cfg.MediaVideoSizeHint.String(), "Size in bytes of max video size referred to on /api/v_/instance endpoints (else, local max size)") + flags.String("media-local-max-size", cfg.MediaLocalMaxSize.String(), "Max size in bytes of media uploaded to this instance via API") + flags.String("media-remote-max-size", cfg.MediaRemoteMaxSize.String(), "Max size in bytes of media to download from other instances") + flags.String("media-cleanup-from", cfg.MediaCleanupFrom, "Time of day from which to start running media cleanup/prune jobs. Should be in the format 'hh:mm:ss', eg., '15:04:05'.") + flags.Duration("media-cleanup-every", cfg.MediaCleanupEvery, "Period to elapse between cleanups, starting from media-cleanup-at.") + flags.Int("media-ffmpeg-pool-size", cfg.MediaFfmpegPoolSize, "Number of instances of the embedded ffmpeg WASM binary to add to the media processing pool. 0 or less uses GOMAXPROCS.") + flags.String("storage-backend", cfg.StorageBackend, "Storage backend to use for media attachments") + flags.String("storage-local-base-path", cfg.StorageLocalBasePath, "Full path to an already-created directory where gts should store/retrieve media files. Subfolders will be created within this dir.") + flags.String("storage-s3-endpoint", cfg.StorageS3Endpoint, "S3 Endpoint URL (e.g 'minio.example.org:9000')") + flags.String("storage-s3-access-key", cfg.StorageS3AccessKey, "S3 Access Key") + flags.String("storage-s3-secret-key", cfg.StorageS3SecretKey, "S3 Secret Key") + flags.Bool("storage-s3-use-ssl", cfg.StorageS3UseSSL, "Use SSL for S3 connections. Only set this to 'false' when testing locally") + flags.String("storage-s3-bucket", cfg.StorageS3BucketName, "Place blobs in this bucket") + flags.Bool("storage-s3-proxy", cfg.StorageS3Proxy, "Proxy S3 contents through GoToSocial instead of redirecting to a presigned URL") + flags.String("storage-s3-redirect-url", cfg.StorageS3RedirectURL, "Custom URL to use for redirecting S3 media links. If set, this will be used instead of the S3 bucket URL.") + flags.String("storage-s3-bucket-lookup", cfg.StorageS3BucketLookup, "S3 bucket lookup type to use. Can be 'auto', 'dns' or 'path'. Defaults to 'auto'.") + flags.Int("statuses-max-chars", cfg.StatusesMaxChars, "Max permitted characters for posted statuses, including content warning") + flags.Int("statuses-poll-max-options", cfg.StatusesPollMaxOptions, "Max amount of options permitted on a poll") + flags.Int("statuses-poll-option-max-chars", cfg.StatusesPollOptionMaxChars, "Max amount of characters for a poll option") + flags.Int("statuses-media-max-files", cfg.StatusesMediaMaxFiles, "Maximum number of media files/attachments per status") + flags.Bool("letsencrypt-enabled", cfg.LetsEncryptEnabled, "Enable letsencrypt TLS certs for this server. If set to true, then cert dir also needs to be set (or take the default).") + flags.Int("letsencrypt-port", cfg.LetsEncryptPort, "Port to listen on for letsencrypt certificate challenges. Must not be the same as the GtS webserver/API port.") + flags.String("letsencrypt-cert-dir", cfg.LetsEncryptCertDir, "Directory to store acquired letsencrypt certificates.") + flags.String("letsencrypt-email-address", cfg.LetsEncryptEmailAddress, "Email address to use when requesting letsencrypt certs. Will receive updates on cert expiry etc.") + flags.String("tls-certificate-chain", cfg.TLSCertificateChain, "Filesystem path to the certificate chain including any intermediate CAs and the TLS public key") + flags.String("tls-certificate-key", cfg.TLSCertificateKey, "Filesystem path to the TLS private key") + flags.Bool("oidc-enabled", cfg.OIDCEnabled, "Enabled OIDC authorization for this instance. If set to true, then the other OIDC flags must also be set.") + flags.String("oidc-idp-name", cfg.OIDCIdpName, "Name of the OIDC identity provider. Will be shown to the user when logging in.") + flags.Bool("oidc-skip-verification", cfg.OIDCSkipVerification, "Skip verification of tokens returned by the OIDC provider. Should only be set to 'true' for testing purposes, never in a production environment!") + flags.String("oidc-issuer", cfg.OIDCIssuer, "Address of the OIDC issuer. Should be the web address, including protocol, at which the issuer can be reached. Eg., 'https://example.org/auth'") + flags.String("oidc-client-id", cfg.OIDCClientID, "ClientID of GoToSocial, as registered with the OIDC provider.") + flags.String("oidc-client-secret", cfg.OIDCClientSecret, "ClientSecret of GoToSocial, as registered with the OIDC provider.") + flags.StringSlice("oidc-scopes", cfg.OIDCScopes, "OIDC scopes.") + flags.Bool("oidc-link-existing", cfg.OIDCLinkExisting, "link existing user accounts to OIDC logins based on the stored email value") + flags.StringSlice("oidc-allowed-groups", cfg.OIDCAllowedGroups, "Membership of one of the listed groups allows access to GtS. If this is empty, all groups are allowed.") + flags.StringSlice("oidc-admin-groups", cfg.OIDCAdminGroups, "Membership of one of the listed groups makes someone a GtS admin") + flags.Bool("tracing-enabled", cfg.TracingEnabled, "Enable OTLP Tracing") + flags.Bool("metrics-enabled", cfg.MetricsEnabled, "Enable OpenTelemetry based metrics support.") + flags.String("smtp-host", cfg.SMTPHost, "Host of the smtp server. Eg., 'smtp.eu.mailgun.org'") + flags.Int("smtp-port", cfg.SMTPPort, "Port of the smtp server. Eg., 587") + flags.String("smtp-username", cfg.SMTPUsername, "Username to authenticate with the smtp server as. Eg., 'postmaster@mail.example.org'") + flags.String("smtp-password", cfg.SMTPPassword, "Password to pass to the smtp server.") + flags.String("smtp-from", cfg.SMTPFrom, "Address to use as the 'from' field of the email. Eg., 'gotosocial@example.org'") + flags.Bool("smtp-disclose-recipients", cfg.SMTPDiscloseRecipients, "If true, email notifications sent to multiple recipients will be To'd to every recipient at once. If false, recipients will not be disclosed") + flags.Bool("syslog-enabled", cfg.SyslogEnabled, "Enable the syslog logging hook. Logs will be mirrored to the configured destination.") + flags.String("syslog-protocol", cfg.SyslogProtocol, "Protocol to use when directing logs to syslog. Leave empty to connect to local syslog.") + flags.String("syslog-address", cfg.SyslogAddress, "Address:port to send syslog logs to. Leave empty to connect to local syslog.") + flags.String("advanced-cookies-samesite", cfg.Advanced.CookiesSamesite, "'strict' or 'lax', see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie/SameSite") + flags.Int("advanced-sender-multiplier", cfg.Advanced.SenderMultiplier, "Multiplier to use per cpu for batching outgoing fedi messages. 0 or less turns batching off (not recommended).") + flags.StringSlice("advanced-csp-extra-uris", cfg.Advanced.CSPExtraURIs, "Additional URIs to allow when building content-security-policy for media + images.") + flags.String("advanced-header-filter-mode", cfg.Advanced.HeaderFilterMode, "Set incoming request header filtering mode.") + flags.Bool("advanced-scraper-deterrence", cfg.Advanced.ScraperDeterrence, "Enable proof-of-work based scraper deterrence on profile / status pages") + flags.Int("advanced-rate-limit-requests", cfg.Advanced.RateLimit.Requests, "Amount of HTTP requests to permit within a 5 minute window. 0 or less turns rate limiting off.") + flags.StringSlice("advanced-rate-limit-exceptions", cfg.Advanced.RateLimit.Exceptions.Strings(), "Slice of CIDRs to exclude from rate limit restrictions.") + flags.Int("advanced-throttling-multiplier", cfg.Advanced.Throttling.Multiplier, "Multiplier to use per cpu for http request throttling. 0 or less turns throttling off.") + flags.Duration("advanced-throttling-retry-after", cfg.Advanced.Throttling.RetryAfter, "Retry-After duration response to send for throttled requests.") + flags.StringSlice("http-client-allow-ips", cfg.HTTPClient.AllowIPs, "") + flags.StringSlice("http-client-block-ips", cfg.HTTPClient.BlockIPs, "") + flags.Duration("http-client-timeout", cfg.HTTPClient.Timeout, "") + flags.Bool("http-client-tls-insecure-skip-verify", cfg.HTTPClient.TLSInsecureSkipVerify, "") + flags.String("cache-memory-target", cfg.Cache.MemoryTarget.String(), "") + flags.Float64("cache-account-mem-ratio", cfg.Cache.AccountMemRatio, "") + flags.Float64("cache-account-note-mem-ratio", cfg.Cache.AccountNoteMemRatio, "") + flags.Float64("cache-account-settings-mem-ratio", cfg.Cache.AccountSettingsMemRatio, "") + flags.Float64("cache-account-stats-mem-ratio", cfg.Cache.AccountStatsMemRatio, "") + flags.Float64("cache-application-mem-ratio", cfg.Cache.ApplicationMemRatio, "") + flags.Float64("cache-block-mem-ratio", cfg.Cache.BlockMemRatio, "") + flags.Float64("cache-block-ids-mem-ratio", cfg.Cache.BlockIDsMemRatio, "") + flags.Float64("cache-boost-of-ids-mem-ratio", cfg.Cache.BoostOfIDsMemRatio, "") + flags.Float64("cache-client-mem-ratio", cfg.Cache.ClientMemRatio, "") + flags.Float64("cache-conversation-mem-ratio", cfg.Cache.ConversationMemRatio, "") + flags.Float64("cache-conversation-last-status-ids-mem-ratio", cfg.Cache.ConversationLastStatusIDsMemRatio, "") + flags.Float64("cache-domain-permission-draft-mem-ratio", cfg.Cache.DomainPermissionDraftMemRation, "") + flags.Float64("cache-domain-permission-subscription-mem-ratio", cfg.Cache.DomainPermissionSubscriptionMemRation, "") + flags.Float64("cache-emoji-mem-ratio", cfg.Cache.EmojiMemRatio, "") + flags.Float64("cache-emoji-category-mem-ratio", cfg.Cache.EmojiCategoryMemRatio, "") + flags.Float64("cache-filter-mem-ratio", cfg.Cache.FilterMemRatio, "") + flags.Float64("cache-filter-keyword-mem-ratio", cfg.Cache.FilterKeywordMemRatio, "") + flags.Float64("cache-filter-status-mem-ratio", cfg.Cache.FilterStatusMemRatio, "") + flags.Float64("cache-follow-mem-ratio", cfg.Cache.FollowMemRatio, "") + flags.Float64("cache-follow-ids-mem-ratio", cfg.Cache.FollowIDsMemRatio, "") + flags.Float64("cache-follow-request-mem-ratio", cfg.Cache.FollowRequestMemRatio, "") + flags.Float64("cache-follow-request-ids-mem-ratio", cfg.Cache.FollowRequestIDsMemRatio, "") + flags.Float64("cache-following-tag-ids-mem-ratio", cfg.Cache.FollowingTagIDsMemRatio, "") + flags.Float64("cache-in-reply-to-ids-mem-ratio", cfg.Cache.InReplyToIDsMemRatio, "") + flags.Float64("cache-instance-mem-ratio", cfg.Cache.InstanceMemRatio, "") + flags.Float64("cache-interaction-request-mem-ratio", cfg.Cache.InteractionRequestMemRatio, "") + flags.Float64("cache-list-mem-ratio", cfg.Cache.ListMemRatio, "") + flags.Float64("cache-list-ids-mem-ratio", cfg.Cache.ListIDsMemRatio, "") + flags.Float64("cache-listed-ids-mem-ratio", cfg.Cache.ListedIDsMemRatio, "") + flags.Float64("cache-marker-mem-ratio", cfg.Cache.MarkerMemRatio, "") + flags.Float64("cache-media-mem-ratio", cfg.Cache.MediaMemRatio, "") + flags.Float64("cache-mention-mem-ratio", cfg.Cache.MentionMemRatio, "") + flags.Float64("cache-move-mem-ratio", cfg.Cache.MoveMemRatio, "") + flags.Float64("cache-notification-mem-ratio", cfg.Cache.NotificationMemRatio, "") + flags.Float64("cache-poll-mem-ratio", cfg.Cache.PollMemRatio, "") + flags.Float64("cache-poll-vote-mem-ratio", cfg.Cache.PollVoteMemRatio, "") + flags.Float64("cache-poll-vote-ids-mem-ratio", cfg.Cache.PollVoteIDsMemRatio, "") + flags.Float64("cache-report-mem-ratio", cfg.Cache.ReportMemRatio, "") + flags.Float64("cache-sin-bin-status-mem-ratio", cfg.Cache.SinBinStatusMemRatio, "") + flags.Float64("cache-status-mem-ratio", cfg.Cache.StatusMemRatio, "") + flags.Float64("cache-status-bookmark-mem-ratio", cfg.Cache.StatusBookmarkMemRatio, "") + flags.Float64("cache-status-bookmark-ids-mem-ratio", cfg.Cache.StatusBookmarkIDsMemRatio, "") + flags.Float64("cache-status-edit-mem-ratio", cfg.Cache.StatusEditMemRatio, "") + flags.Float64("cache-status-fave-mem-ratio", cfg.Cache.StatusFaveMemRatio, "") + flags.Float64("cache-status-fave-ids-mem-ratio", cfg.Cache.StatusFaveIDsMemRatio, "") + flags.Float64("cache-tag-mem-ratio", cfg.Cache.TagMemRatio, "") + flags.Float64("cache-thread-mute-mem-ratio", cfg.Cache.ThreadMuteMemRatio, "") + flags.Float64("cache-token-mem-ratio", cfg.Cache.TokenMemRatio, "") + flags.Float64("cache-tombstone-mem-ratio", cfg.Cache.TombstoneMemRatio, "") + flags.Float64("cache-user-mem-ratio", cfg.Cache.UserMemRatio, "") + flags.Float64("cache-user-mute-mem-ratio", cfg.Cache.UserMuteMemRatio, "") + flags.Float64("cache-user-mute-ids-mem-ratio", cfg.Cache.UserMuteIDsMemRatio, "") + flags.Float64("cache-webfinger-mem-ratio", cfg.Cache.WebfingerMemRatio, "") + flags.Float64("cache-web-push-subscription-mem-ratio", cfg.Cache.WebPushSubscriptionMemRatio, "") + flags.Float64("cache-web-push-subscription-ids-mem-ratio", cfg.Cache.WebPushSubscriptionIDsMemRatio, "") + flags.Float64("cache-visibility-mem-ratio", cfg.Cache.VisibilityMemRatio, "") +} + +func (cfg *Configuration) MarshalMap() map[string]any { + cfgmap := make(map[string]any, 180) + cfgmap["log-level"] = cfg.LogLevel + cfgmap["log-timestamp-format"] = cfg.LogTimestampFormat + cfgmap["log-db-queries"] = cfg.LogDbQueries + cfgmap["log-client-ip"] = cfg.LogClientIP + cfgmap["request-id-header"] = cfg.RequestIDHeader + cfgmap["config-path"] = cfg.ConfigPath + cfgmap["application-name"] = cfg.ApplicationName + cfgmap["landing-page-user"] = cfg.LandingPageUser + cfgmap["host"] = cfg.Host + cfgmap["account-domain"] = cfg.AccountDomain + cfgmap["protocol"] = cfg.Protocol + cfgmap["bind-address"] = cfg.BindAddress + cfgmap["port"] = cfg.Port + cfgmap["trusted-proxies"] = cfg.TrustedProxies + cfgmap["software-version"] = cfg.SoftwareVersion + cfgmap["db-type"] = cfg.DbType + cfgmap["db-address"] = cfg.DbAddress + cfgmap["db-port"] = cfg.DbPort + cfgmap["db-user"] = cfg.DbUser + cfgmap["db-password"] = cfg.DbPassword + cfgmap["db-database"] = cfg.DbDatabase + cfgmap["db-tls-mode"] = cfg.DbTLSMode + cfgmap["db-tls-ca-cert"] = cfg.DbTLSCACert + cfgmap["db-max-open-conns-multiplier"] = cfg.DbMaxOpenConnsMultiplier + cfgmap["db-sqlite-journal-mode"] = cfg.DbSqliteJournalMode + cfgmap["db-sqlite-synchronous"] = cfg.DbSqliteSynchronous + cfgmap["db-sqlite-cache-size"] = cfg.DbSqliteCacheSize.String() + cfgmap["db-sqlite-busy-timeout"] = cfg.DbSqliteBusyTimeout + cfgmap["db-postgres-connection-string"] = cfg.DbPostgresConnectionString + cfgmap["web-template-base-dir"] = cfg.WebTemplateBaseDir + cfgmap["web-asset-base-dir"] = cfg.WebAssetBaseDir + cfgmap["instance-federation-mode"] = cfg.InstanceFederationMode + cfgmap["instance-federation-spam-filter"] = cfg.InstanceFederationSpamFilter + cfgmap["instance-expose-peers"] = cfg.InstanceExposePeers + cfgmap["instance-expose-suspended"] = cfg.InstanceExposeSuspended + cfgmap["instance-expose-suspended-web"] = cfg.InstanceExposeSuspendedWeb + cfgmap["instance-expose-public-timeline"] = cfg.InstanceExposePublicTimeline + cfgmap["instance-deliver-to-shared-inboxes"] = cfg.InstanceDeliverToSharedInboxes + cfgmap["instance-inject-mastodon-version"] = cfg.InstanceInjectMastodonVersion + cfgmap["instance-languages"] = cfg.InstanceLanguages.Strings() + cfgmap["instance-subscriptions-process-from"] = cfg.InstanceSubscriptionsProcessFrom + cfgmap["instance-subscriptions-process-every"] = cfg.InstanceSubscriptionsProcessEvery + cfgmap["instance-stats-mode"] = cfg.InstanceStatsMode + cfgmap["instance-allow-backdating-statuses"] = cfg.InstanceAllowBackdatingStatuses + cfgmap["accounts-registration-open"] = cfg.AccountsRegistrationOpen + cfgmap["accounts-reason-required"] = cfg.AccountsReasonRequired + cfgmap["accounts-registration-daily-limit"] = cfg.AccountsRegistrationDailyLimit + cfgmap["accounts-registration-backlog-limit"] = cfg.AccountsRegistrationBacklogLimit + cfgmap["accounts-allow-custom-css"] = cfg.AccountsAllowCustomCSS + cfgmap["accounts-custom-css-length"] = cfg.AccountsCustomCSSLength + cfgmap["media-description-min-chars"] = cfg.MediaDescriptionMinChars + cfgmap["media-description-max-chars"] = cfg.MediaDescriptionMaxChars + cfgmap["media-remote-cache-days"] = cfg.MediaRemoteCacheDays + cfgmap["media-emoji-local-max-size"] = cfg.MediaEmojiLocalMaxSize.String() + cfgmap["media-emoji-remote-max-size"] = cfg.MediaEmojiRemoteMaxSize.String() + cfgmap["media-image-size-hint"] = cfg.MediaImageSizeHint.String() + cfgmap["media-video-size-hint"] = cfg.MediaVideoSizeHint.String() + cfgmap["media-local-max-size"] = cfg.MediaLocalMaxSize.String() + cfgmap["media-remote-max-size"] = cfg.MediaRemoteMaxSize.String() + cfgmap["media-cleanup-from"] = cfg.MediaCleanupFrom + cfgmap["media-cleanup-every"] = cfg.MediaCleanupEvery + cfgmap["media-ffmpeg-pool-size"] = cfg.MediaFfmpegPoolSize + cfgmap["storage-backend"] = cfg.StorageBackend + cfgmap["storage-local-base-path"] = cfg.StorageLocalBasePath + cfgmap["storage-s3-endpoint"] = cfg.StorageS3Endpoint + cfgmap["storage-s3-access-key"] = cfg.StorageS3AccessKey + cfgmap["storage-s3-secret-key"] = cfg.StorageS3SecretKey + cfgmap["storage-s3-use-ssl"] = cfg.StorageS3UseSSL + cfgmap["storage-s3-bucket"] = cfg.StorageS3BucketName + cfgmap["storage-s3-proxy"] = cfg.StorageS3Proxy + cfgmap["storage-s3-redirect-url"] = cfg.StorageS3RedirectURL + cfgmap["storage-s3-bucket-lookup"] = cfg.StorageS3BucketLookup + cfgmap["statuses-max-chars"] = cfg.StatusesMaxChars + cfgmap["statuses-poll-max-options"] = cfg.StatusesPollMaxOptions + cfgmap["statuses-poll-option-max-chars"] = cfg.StatusesPollOptionMaxChars + cfgmap["statuses-media-max-files"] = cfg.StatusesMediaMaxFiles + cfgmap["letsencrypt-enabled"] = cfg.LetsEncryptEnabled + cfgmap["letsencrypt-port"] = cfg.LetsEncryptPort + cfgmap["letsencrypt-cert-dir"] = cfg.LetsEncryptCertDir + cfgmap["letsencrypt-email-address"] = cfg.LetsEncryptEmailAddress + cfgmap["tls-certificate-chain"] = cfg.TLSCertificateChain + cfgmap["tls-certificate-key"] = cfg.TLSCertificateKey + cfgmap["oidc-enabled"] = cfg.OIDCEnabled + cfgmap["oidc-idp-name"] = cfg.OIDCIdpName + cfgmap["oidc-skip-verification"] = cfg.OIDCSkipVerification + cfgmap["oidc-issuer"] = cfg.OIDCIssuer + cfgmap["oidc-client-id"] = cfg.OIDCClientID + cfgmap["oidc-client-secret"] = cfg.OIDCClientSecret + cfgmap["oidc-scopes"] = cfg.OIDCScopes + cfgmap["oidc-link-existing"] = cfg.OIDCLinkExisting + cfgmap["oidc-allowed-groups"] = cfg.OIDCAllowedGroups + cfgmap["oidc-admin-groups"] = cfg.OIDCAdminGroups + cfgmap["tracing-enabled"] = cfg.TracingEnabled + cfgmap["metrics-enabled"] = cfg.MetricsEnabled + cfgmap["smtp-host"] = cfg.SMTPHost + cfgmap["smtp-port"] = cfg.SMTPPort + cfgmap["smtp-username"] = cfg.SMTPUsername + cfgmap["smtp-password"] = cfg.SMTPPassword + cfgmap["smtp-from"] = cfg.SMTPFrom + cfgmap["smtp-disclose-recipients"] = cfg.SMTPDiscloseRecipients + cfgmap["syslog-enabled"] = cfg.SyslogEnabled + cfgmap["syslog-protocol"] = cfg.SyslogProtocol + cfgmap["syslog-address"] = cfg.SyslogAddress + cfgmap["advanced-cookies-samesite"] = cfg.Advanced.CookiesSamesite + cfgmap["advanced-sender-multiplier"] = cfg.Advanced.SenderMultiplier + cfgmap["advanced-csp-extra-uris"] = cfg.Advanced.CSPExtraURIs + cfgmap["advanced-header-filter-mode"] = cfg.Advanced.HeaderFilterMode + cfgmap["advanced-scraper-deterrence"] = cfg.Advanced.ScraperDeterrence + cfgmap["advanced-rate-limit-requests"] = cfg.Advanced.RateLimit.Requests + cfgmap["advanced-rate-limit-exceptions"] = cfg.Advanced.RateLimit.Exceptions.Strings() + cfgmap["advanced-throttling-multiplier"] = cfg.Advanced.Throttling.Multiplier + cfgmap["advanced-throttling-retry-after"] = cfg.Advanced.Throttling.RetryAfter + cfgmap["http-client-allow-ips"] = cfg.HTTPClient.AllowIPs + cfgmap["http-client-block-ips"] = cfg.HTTPClient.BlockIPs + cfgmap["http-client-timeout"] = cfg.HTTPClient.Timeout + cfgmap["http-client-tls-insecure-skip-verify"] = cfg.HTTPClient.TLSInsecureSkipVerify + cfgmap["cache-memory-target"] = cfg.Cache.MemoryTarget.String() + cfgmap["cache-account-mem-ratio"] = cfg.Cache.AccountMemRatio + cfgmap["cache-account-note-mem-ratio"] = cfg.Cache.AccountNoteMemRatio + cfgmap["cache-account-settings-mem-ratio"] = cfg.Cache.AccountSettingsMemRatio + cfgmap["cache-account-stats-mem-ratio"] = cfg.Cache.AccountStatsMemRatio + cfgmap["cache-application-mem-ratio"] = cfg.Cache.ApplicationMemRatio + cfgmap["cache-block-mem-ratio"] = cfg.Cache.BlockMemRatio + cfgmap["cache-block-ids-mem-ratio"] = cfg.Cache.BlockIDsMemRatio + cfgmap["cache-boost-of-ids-mem-ratio"] = cfg.Cache.BoostOfIDsMemRatio + cfgmap["cache-client-mem-ratio"] = cfg.Cache.ClientMemRatio + cfgmap["cache-conversation-mem-ratio"] = cfg.Cache.ConversationMemRatio + cfgmap["cache-conversation-last-status-ids-mem-ratio"] = cfg.Cache.ConversationLastStatusIDsMemRatio + cfgmap["cache-domain-permission-draft-mem-ratio"] = cfg.Cache.DomainPermissionDraftMemRation + cfgmap["cache-domain-permission-subscription-mem-ratio"] = cfg.Cache.DomainPermissionSubscriptionMemRation + cfgmap["cache-emoji-mem-ratio"] = cfg.Cache.EmojiMemRatio + cfgmap["cache-emoji-category-mem-ratio"] = cfg.Cache.EmojiCategoryMemRatio + cfgmap["cache-filter-mem-ratio"] = cfg.Cache.FilterMemRatio + cfgmap["cache-filter-keyword-mem-ratio"] = cfg.Cache.FilterKeywordMemRatio + cfgmap["cache-filter-status-mem-ratio"] = cfg.Cache.FilterStatusMemRatio + cfgmap["cache-follow-mem-ratio"] = cfg.Cache.FollowMemRatio + cfgmap["cache-follow-ids-mem-ratio"] = cfg.Cache.FollowIDsMemRatio + cfgmap["cache-follow-request-mem-ratio"] = cfg.Cache.FollowRequestMemRatio + cfgmap["cache-follow-request-ids-mem-ratio"] = cfg.Cache.FollowRequestIDsMemRatio + cfgmap["cache-following-tag-ids-mem-ratio"] = cfg.Cache.FollowingTagIDsMemRatio + cfgmap["cache-in-reply-to-ids-mem-ratio"] = cfg.Cache.InReplyToIDsMemRatio + cfgmap["cache-instance-mem-ratio"] = cfg.Cache.InstanceMemRatio + cfgmap["cache-interaction-request-mem-ratio"] = cfg.Cache.InteractionRequestMemRatio + cfgmap["cache-list-mem-ratio"] = cfg.Cache.ListMemRatio + cfgmap["cache-list-ids-mem-ratio"] = cfg.Cache.ListIDsMemRatio + cfgmap["cache-listed-ids-mem-ratio"] = cfg.Cache.ListedIDsMemRatio + cfgmap["cache-marker-mem-ratio"] = cfg.Cache.MarkerMemRatio + cfgmap["cache-media-mem-ratio"] = cfg.Cache.MediaMemRatio + cfgmap["cache-mention-mem-ratio"] = cfg.Cache.MentionMemRatio + cfgmap["cache-move-mem-ratio"] = cfg.Cache.MoveMemRatio + cfgmap["cache-notification-mem-ratio"] = cfg.Cache.NotificationMemRatio + cfgmap["cache-poll-mem-ratio"] = cfg.Cache.PollMemRatio + cfgmap["cache-poll-vote-mem-ratio"] = cfg.Cache.PollVoteMemRatio + cfgmap["cache-poll-vote-ids-mem-ratio"] = cfg.Cache.PollVoteIDsMemRatio + cfgmap["cache-report-mem-ratio"] = cfg.Cache.ReportMemRatio + cfgmap["cache-sin-bin-status-mem-ratio"] = cfg.Cache.SinBinStatusMemRatio + cfgmap["cache-status-mem-ratio"] = cfg.Cache.StatusMemRatio + cfgmap["cache-status-bookmark-mem-ratio"] = cfg.Cache.StatusBookmarkMemRatio + cfgmap["cache-status-bookmark-ids-mem-ratio"] = cfg.Cache.StatusBookmarkIDsMemRatio + cfgmap["cache-status-edit-mem-ratio"] = cfg.Cache.StatusEditMemRatio + cfgmap["cache-status-fave-mem-ratio"] = cfg.Cache.StatusFaveMemRatio + cfgmap["cache-status-fave-ids-mem-ratio"] = cfg.Cache.StatusFaveIDsMemRatio + cfgmap["cache-tag-mem-ratio"] = cfg.Cache.TagMemRatio + cfgmap["cache-thread-mute-mem-ratio"] = cfg.Cache.ThreadMuteMemRatio + cfgmap["cache-token-mem-ratio"] = cfg.Cache.TokenMemRatio + cfgmap["cache-tombstone-mem-ratio"] = cfg.Cache.TombstoneMemRatio + cfgmap["cache-user-mem-ratio"] = cfg.Cache.UserMemRatio + cfgmap["cache-user-mute-mem-ratio"] = cfg.Cache.UserMuteMemRatio + cfgmap["cache-user-mute-ids-mem-ratio"] = cfg.Cache.UserMuteIDsMemRatio + cfgmap["cache-webfinger-mem-ratio"] = cfg.Cache.WebfingerMemRatio + cfgmap["cache-web-push-subscription-mem-ratio"] = cfg.Cache.WebPushSubscriptionMemRatio + cfgmap["cache-web-push-subscription-ids-mem-ratio"] = cfg.Cache.WebPushSubscriptionIDsMemRatio + cfgmap["cache-visibility-mem-ratio"] = cfg.Cache.VisibilityMemRatio + cfgmap["username"] = cfg.AdminAccountUsername + cfgmap["email"] = cfg.AdminAccountEmail + cfgmap["password"] = cfg.AdminAccountPassword + cfgmap["path"] = cfg.AdminTransPath + cfgmap["dry-run"] = cfg.AdminMediaPruneDryRun + cfgmap["local-only"] = cfg.AdminMediaListLocalOnly + cfgmap["remote-only"] = cfg.AdminMediaListRemoteOnly + return cfgmap +} + +func (cfg *Configuration) UnmarshalMap(cfgmap map[string]any) error { + // VERY IMPORTANT FIRST STEP! + // flatten to normalize map to + // entirely un-nested key values + flattenConfigMap(cfgmap) + + if ival, ok := cfgmap["log-level"]; ok { + var err error + cfg.LogLevel, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'log-level': %w", ival, err) + } + } + + if ival, ok := cfgmap["log-timestamp-format"]; ok { + var err error + cfg.LogTimestampFormat, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'log-timestamp-format': %w", ival, err) + } + } + + if ival, ok := cfgmap["log-db-queries"]; ok { + var err error + cfg.LogDbQueries, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'log-db-queries': %w", ival, err) + } + } + + if ival, ok := cfgmap["log-client-ip"]; ok { + var err error + cfg.LogClientIP, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'log-client-ip': %w", ival, err) + } + } + + if ival, ok := cfgmap["request-id-header"]; ok { + var err error + cfg.RequestIDHeader, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'request-id-header': %w", ival, err) + } + } + + if ival, ok := cfgmap["config-path"]; ok { + var err error + cfg.ConfigPath, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'config-path': %w", ival, err) + } + } + + if ival, ok := cfgmap["application-name"]; ok { + var err error + cfg.ApplicationName, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'application-name': %w", ival, err) + } + } + + if ival, ok := cfgmap["landing-page-user"]; ok { + var err error + cfg.LandingPageUser, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'landing-page-user': %w", ival, err) + } + } + + if ival, ok := cfgmap["host"]; ok { + var err error + cfg.Host, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'host': %w", ival, err) + } + } + + if ival, ok := cfgmap["account-domain"]; ok { + var err error + cfg.AccountDomain, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'account-domain': %w", ival, err) + } + } + + if ival, ok := cfgmap["protocol"]; ok { + var err error + cfg.Protocol, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'protocol': %w", ival, err) + } + } + + if ival, ok := cfgmap["bind-address"]; ok { + var err error + cfg.BindAddress, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'bind-address': %w", ival, err) + } + } + + if ival, ok := cfgmap["port"]; ok { + var err error + cfg.Port, err = cast.ToIntE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> int for 'port': %w", ival, err) + } + } + + if ival, ok := cfgmap["trusted-proxies"]; ok { + var err error + cfg.TrustedProxies, err = toStringSlice(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> []string for 'trusted-proxies': %w", ival, err) + } + } + + if ival, ok := cfgmap["software-version"]; ok { + var err error + cfg.SoftwareVersion, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'software-version': %w", ival, err) + } + } + + if ival, ok := cfgmap["db-type"]; ok { + var err error + cfg.DbType, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'db-type': %w", ival, err) + } + } + + if ival, ok := cfgmap["db-address"]; ok { + var err error + cfg.DbAddress, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'db-address': %w", ival, err) + } + } + + if ival, ok := cfgmap["db-port"]; ok { + var err error + cfg.DbPort, err = cast.ToIntE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> int for 'db-port': %w", ival, err) + } + } + + if ival, ok := cfgmap["db-user"]; ok { + var err error + cfg.DbUser, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'db-user': %w", ival, err) + } + } + + if ival, ok := cfgmap["db-password"]; ok { + var err error + cfg.DbPassword, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'db-password': %w", ival, err) + } + } + + if ival, ok := cfgmap["db-database"]; ok { + var err error + cfg.DbDatabase, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'db-database': %w", ival, err) + } + } + + if ival, ok := cfgmap["db-tls-mode"]; ok { + var err error + cfg.DbTLSMode, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'db-tls-mode': %w", ival, err) + } + } + + if ival, ok := cfgmap["db-tls-ca-cert"]; ok { + var err error + cfg.DbTLSCACert, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'db-tls-ca-cert': %w", ival, err) + } + } + + if ival, ok := cfgmap["db-max-open-conns-multiplier"]; ok { + var err error + cfg.DbMaxOpenConnsMultiplier, err = cast.ToIntE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> int for 'db-max-open-conns-multiplier': %w", ival, err) + } + } + + if ival, ok := cfgmap["db-sqlite-journal-mode"]; ok { + var err error + cfg.DbSqliteJournalMode, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'db-sqlite-journal-mode': %w", ival, err) + } + } + + if ival, ok := cfgmap["db-sqlite-synchronous"]; ok { + var err error + cfg.DbSqliteSynchronous, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'db-sqlite-synchronous': %w", ival, err) + } + } + + if ival, ok := cfgmap["db-sqlite-cache-size"]; ok { + t, err := cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'db-sqlite-cache-size': %w", ival, err) + } + cfg.DbSqliteCacheSize = 0x0 + if err := cfg.DbSqliteCacheSize.Set(t); err != nil { + return fmt.Errorf("error parsing %#v for 'db-sqlite-cache-size': %w", ival, err) + } + } + + if ival, ok := cfgmap["db-sqlite-busy-timeout"]; ok { + var err error + cfg.DbSqliteBusyTimeout, err = cast.ToDurationE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> time.Duration for 'db-sqlite-busy-timeout': %w", ival, err) + } + } + + if ival, ok := cfgmap["db-postgres-connection-string"]; ok { + var err error + cfg.DbPostgresConnectionString, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'db-postgres-connection-string': %w", ival, err) + } + } + + if ival, ok := cfgmap["web-template-base-dir"]; ok { + var err error + cfg.WebTemplateBaseDir, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'web-template-base-dir': %w", ival, err) + } + } + + if ival, ok := cfgmap["web-asset-base-dir"]; ok { + var err error + cfg.WebAssetBaseDir, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'web-asset-base-dir': %w", ival, err) + } + } + + if ival, ok := cfgmap["instance-federation-mode"]; ok { + var err error + cfg.InstanceFederationMode, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'instance-federation-mode': %w", ival, err) + } + } + + if ival, ok := cfgmap["instance-federation-spam-filter"]; ok { + var err error + cfg.InstanceFederationSpamFilter, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'instance-federation-spam-filter': %w", ival, err) + } + } + + if ival, ok := cfgmap["instance-expose-peers"]; ok { + var err error + cfg.InstanceExposePeers, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'instance-expose-peers': %w", ival, err) + } + } + + if ival, ok := cfgmap["instance-expose-suspended"]; ok { + var err error + cfg.InstanceExposeSuspended, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'instance-expose-suspended': %w", ival, err) + } + } + + if ival, ok := cfgmap["instance-expose-suspended-web"]; ok { + var err error + cfg.InstanceExposeSuspendedWeb, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'instance-expose-suspended-web': %w", ival, err) + } + } + + if ival, ok := cfgmap["instance-expose-public-timeline"]; ok { + var err error + cfg.InstanceExposePublicTimeline, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'instance-expose-public-timeline': %w", ival, err) + } + } + + if ival, ok := cfgmap["instance-deliver-to-shared-inboxes"]; ok { + var err error + cfg.InstanceDeliverToSharedInboxes, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'instance-deliver-to-shared-inboxes': %w", ival, err) + } + } + + if ival, ok := cfgmap["instance-inject-mastodon-version"]; ok { + var err error + cfg.InstanceInjectMastodonVersion, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'instance-inject-mastodon-version': %w", ival, err) + } + } + + if ival, ok := cfgmap["instance-languages"]; ok { + t, err := toStringSlice(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> []string for 'instance-languages': %w", ival, err) + } + cfg.InstanceLanguages = language.Languages{} + for _, in := range t { + if err := cfg.InstanceLanguages.Set(in); err != nil { + return fmt.Errorf("error parsing %#v for 'instance-languages': %w", ival, err) + } + } + } + + if ival, ok := cfgmap["instance-subscriptions-process-from"]; ok { + var err error + cfg.InstanceSubscriptionsProcessFrom, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'instance-subscriptions-process-from': %w", ival, err) + } + } + + if ival, ok := cfgmap["instance-subscriptions-process-every"]; ok { + var err error + cfg.InstanceSubscriptionsProcessEvery, err = cast.ToDurationE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> time.Duration for 'instance-subscriptions-process-every': %w", ival, err) + } + } + + if ival, ok := cfgmap["instance-stats-mode"]; ok { + var err error + cfg.InstanceStatsMode, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'instance-stats-mode': %w", ival, err) + } + } + + if ival, ok := cfgmap["instance-allow-backdating-statuses"]; ok { + var err error + cfg.InstanceAllowBackdatingStatuses, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'instance-allow-backdating-statuses': %w", ival, err) + } + } + + if ival, ok := cfgmap["accounts-registration-open"]; ok { + var err error + cfg.AccountsRegistrationOpen, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'accounts-registration-open': %w", ival, err) + } + } + + if ival, ok := cfgmap["accounts-reason-required"]; ok { + var err error + cfg.AccountsReasonRequired, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'accounts-reason-required': %w", ival, err) + } + } + + if ival, ok := cfgmap["accounts-registration-daily-limit"]; ok { + var err error + cfg.AccountsRegistrationDailyLimit, err = cast.ToIntE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> int for 'accounts-registration-daily-limit': %w", ival, err) + } + } + + if ival, ok := cfgmap["accounts-registration-backlog-limit"]; ok { + var err error + cfg.AccountsRegistrationBacklogLimit, err = cast.ToIntE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> int for 'accounts-registration-backlog-limit': %w", ival, err) + } + } + + if ival, ok := cfgmap["accounts-allow-custom-css"]; ok { + var err error + cfg.AccountsAllowCustomCSS, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'accounts-allow-custom-css': %w", ival, err) + } + } + + if ival, ok := cfgmap["accounts-custom-css-length"]; ok { + var err error + cfg.AccountsCustomCSSLength, err = cast.ToIntE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> int for 'accounts-custom-css-length': %w", ival, err) + } + } + + if ival, ok := cfgmap["media-description-min-chars"]; ok { + var err error + cfg.MediaDescriptionMinChars, err = cast.ToIntE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> int for 'media-description-min-chars': %w", ival, err) + } + } + + if ival, ok := cfgmap["media-description-max-chars"]; ok { + var err error + cfg.MediaDescriptionMaxChars, err = cast.ToIntE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> int for 'media-description-max-chars': %w", ival, err) + } + } + + if ival, ok := cfgmap["media-remote-cache-days"]; ok { + var err error + cfg.MediaRemoteCacheDays, err = cast.ToIntE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> int for 'media-remote-cache-days': %w", ival, err) + } + } + + if ival, ok := cfgmap["media-emoji-local-max-size"]; ok { + t, err := cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'media-emoji-local-max-size': %w", ival, err) + } + cfg.MediaEmojiLocalMaxSize = 0x0 + if err := cfg.MediaEmojiLocalMaxSize.Set(t); err != nil { + return fmt.Errorf("error parsing %#v for 'media-emoji-local-max-size': %w", ival, err) + } + } + + if ival, ok := cfgmap["media-emoji-remote-max-size"]; ok { + t, err := cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'media-emoji-remote-max-size': %w", ival, err) + } + cfg.MediaEmojiRemoteMaxSize = 0x0 + if err := cfg.MediaEmojiRemoteMaxSize.Set(t); err != nil { + return fmt.Errorf("error parsing %#v for 'media-emoji-remote-max-size': %w", ival, err) + } + } + + if ival, ok := cfgmap["media-image-size-hint"]; ok { + t, err := cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'media-image-size-hint': %w", ival, err) + } + cfg.MediaImageSizeHint = 0x0 + if err := cfg.MediaImageSizeHint.Set(t); err != nil { + return fmt.Errorf("error parsing %#v for 'media-image-size-hint': %w", ival, err) + } + } + + if ival, ok := cfgmap["media-video-size-hint"]; ok { + t, err := cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'media-video-size-hint': %w", ival, err) + } + cfg.MediaVideoSizeHint = 0x0 + if err := cfg.MediaVideoSizeHint.Set(t); err != nil { + return fmt.Errorf("error parsing %#v for 'media-video-size-hint': %w", ival, err) + } + } + + if ival, ok := cfgmap["media-local-max-size"]; ok { + t, err := cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'media-local-max-size': %w", ival, err) + } + cfg.MediaLocalMaxSize = 0x0 + if err := cfg.MediaLocalMaxSize.Set(t); err != nil { + return fmt.Errorf("error parsing %#v for 'media-local-max-size': %w", ival, err) + } + } + + if ival, ok := cfgmap["media-remote-max-size"]; ok { + t, err := cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'media-remote-max-size': %w", ival, err) + } + cfg.MediaRemoteMaxSize = 0x0 + if err := cfg.MediaRemoteMaxSize.Set(t); err != nil { + return fmt.Errorf("error parsing %#v for 'media-remote-max-size': %w", ival, err) + } + } + + if ival, ok := cfgmap["media-cleanup-from"]; ok { + var err error + cfg.MediaCleanupFrom, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'media-cleanup-from': %w", ival, err) + } + } + + if ival, ok := cfgmap["media-cleanup-every"]; ok { + var err error + cfg.MediaCleanupEvery, err = cast.ToDurationE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> time.Duration for 'media-cleanup-every': %w", ival, err) + } + } + + if ival, ok := cfgmap["media-ffmpeg-pool-size"]; ok { + var err error + cfg.MediaFfmpegPoolSize, err = cast.ToIntE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> int for 'media-ffmpeg-pool-size': %w", ival, err) + } + } + + if ival, ok := cfgmap["storage-backend"]; ok { + var err error + cfg.StorageBackend, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'storage-backend': %w", ival, err) + } + } + + if ival, ok := cfgmap["storage-local-base-path"]; ok { + var err error + cfg.StorageLocalBasePath, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'storage-local-base-path': %w", ival, err) + } + } + + if ival, ok := cfgmap["storage-s3-endpoint"]; ok { + var err error + cfg.StorageS3Endpoint, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'storage-s3-endpoint': %w", ival, err) + } + } + + if ival, ok := cfgmap["storage-s3-access-key"]; ok { + var err error + cfg.StorageS3AccessKey, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'storage-s3-access-key': %w", ival, err) + } + } + + if ival, ok := cfgmap["storage-s3-secret-key"]; ok { + var err error + cfg.StorageS3SecretKey, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'storage-s3-secret-key': %w", ival, err) + } + } + + if ival, ok := cfgmap["storage-s3-use-ssl"]; ok { + var err error + cfg.StorageS3UseSSL, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'storage-s3-use-ssl': %w", ival, err) + } + } + + if ival, ok := cfgmap["storage-s3-bucket"]; ok { + var err error + cfg.StorageS3BucketName, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'storage-s3-bucket': %w", ival, err) + } + } + + if ival, ok := cfgmap["storage-s3-proxy"]; ok { + var err error + cfg.StorageS3Proxy, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'storage-s3-proxy': %w", ival, err) + } + } + + if ival, ok := cfgmap["storage-s3-redirect-url"]; ok { + var err error + cfg.StorageS3RedirectURL, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'storage-s3-redirect-url': %w", ival, err) + } + } + + if ival, ok := cfgmap["storage-s3-bucket-lookup"]; ok { + var err error + cfg.StorageS3BucketLookup, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'storage-s3-bucket-lookup': %w", ival, err) + } + } + + if ival, ok := cfgmap["statuses-max-chars"]; ok { + var err error + cfg.StatusesMaxChars, err = cast.ToIntE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> int for 'statuses-max-chars': %w", ival, err) + } + } + + if ival, ok := cfgmap["statuses-poll-max-options"]; ok { + var err error + cfg.StatusesPollMaxOptions, err = cast.ToIntE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> int for 'statuses-poll-max-options': %w", ival, err) + } + } + + if ival, ok := cfgmap["statuses-poll-option-max-chars"]; ok { + var err error + cfg.StatusesPollOptionMaxChars, err = cast.ToIntE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> int for 'statuses-poll-option-max-chars': %w", ival, err) + } + } + + if ival, ok := cfgmap["statuses-media-max-files"]; ok { + var err error + cfg.StatusesMediaMaxFiles, err = cast.ToIntE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> int for 'statuses-media-max-files': %w", ival, err) + } + } + + if ival, ok := cfgmap["letsencrypt-enabled"]; ok { + var err error + cfg.LetsEncryptEnabled, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'letsencrypt-enabled': %w", ival, err) + } + } + + if ival, ok := cfgmap["letsencrypt-port"]; ok { + var err error + cfg.LetsEncryptPort, err = cast.ToIntE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> int for 'letsencrypt-port': %w", ival, err) + } + } + + if ival, ok := cfgmap["letsencrypt-cert-dir"]; ok { + var err error + cfg.LetsEncryptCertDir, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'letsencrypt-cert-dir': %w", ival, err) + } + } + + if ival, ok := cfgmap["letsencrypt-email-address"]; ok { + var err error + cfg.LetsEncryptEmailAddress, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'letsencrypt-email-address': %w", ival, err) + } + } + + if ival, ok := cfgmap["tls-certificate-chain"]; ok { + var err error + cfg.TLSCertificateChain, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'tls-certificate-chain': %w", ival, err) + } + } + + if ival, ok := cfgmap["tls-certificate-key"]; ok { + var err error + cfg.TLSCertificateKey, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'tls-certificate-key': %w", ival, err) + } + } + + if ival, ok := cfgmap["oidc-enabled"]; ok { + var err error + cfg.OIDCEnabled, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'oidc-enabled': %w", ival, err) + } + } + + if ival, ok := cfgmap["oidc-idp-name"]; ok { + var err error + cfg.OIDCIdpName, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'oidc-idp-name': %w", ival, err) + } + } + + if ival, ok := cfgmap["oidc-skip-verification"]; ok { + var err error + cfg.OIDCSkipVerification, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'oidc-skip-verification': %w", ival, err) + } + } + + if ival, ok := cfgmap["oidc-issuer"]; ok { + var err error + cfg.OIDCIssuer, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'oidc-issuer': %w", ival, err) + } + } + + if ival, ok := cfgmap["oidc-client-id"]; ok { + var err error + cfg.OIDCClientID, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'oidc-client-id': %w", ival, err) + } + } + + if ival, ok := cfgmap["oidc-client-secret"]; ok { + var err error + cfg.OIDCClientSecret, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'oidc-client-secret': %w", ival, err) + } + } + + if ival, ok := cfgmap["oidc-scopes"]; ok { + var err error + cfg.OIDCScopes, err = toStringSlice(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> []string for 'oidc-scopes': %w", ival, err) + } + } + + if ival, ok := cfgmap["oidc-link-existing"]; ok { + var err error + cfg.OIDCLinkExisting, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'oidc-link-existing': %w", ival, err) + } + } + + if ival, ok := cfgmap["oidc-allowed-groups"]; ok { + var err error + cfg.OIDCAllowedGroups, err = toStringSlice(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> []string for 'oidc-allowed-groups': %w", ival, err) + } + } + + if ival, ok := cfgmap["oidc-admin-groups"]; ok { + var err error + cfg.OIDCAdminGroups, err = toStringSlice(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> []string for 'oidc-admin-groups': %w", ival, err) + } + } + + if ival, ok := cfgmap["tracing-enabled"]; ok { + var err error + cfg.TracingEnabled, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'tracing-enabled': %w", ival, err) + } + } + + if ival, ok := cfgmap["metrics-enabled"]; ok { + var err error + cfg.MetricsEnabled, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'metrics-enabled': %w", ival, err) + } + } + + if ival, ok := cfgmap["smtp-host"]; ok { + var err error + cfg.SMTPHost, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'smtp-host': %w", ival, err) + } + } + + if ival, ok := cfgmap["smtp-port"]; ok { + var err error + cfg.SMTPPort, err = cast.ToIntE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> int for 'smtp-port': %w", ival, err) + } + } + + if ival, ok := cfgmap["smtp-username"]; ok { + var err error + cfg.SMTPUsername, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'smtp-username': %w", ival, err) + } + } + + if ival, ok := cfgmap["smtp-password"]; ok { + var err error + cfg.SMTPPassword, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'smtp-password': %w", ival, err) + } + } + + if ival, ok := cfgmap["smtp-from"]; ok { + var err error + cfg.SMTPFrom, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'smtp-from': %w", ival, err) + } + } + + if ival, ok := cfgmap["smtp-disclose-recipients"]; ok { + var err error + cfg.SMTPDiscloseRecipients, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'smtp-disclose-recipients': %w", ival, err) + } + } + + if ival, ok := cfgmap["syslog-enabled"]; ok { + var err error + cfg.SyslogEnabled, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'syslog-enabled': %w", ival, err) + } + } + + if ival, ok := cfgmap["syslog-protocol"]; ok { + var err error + cfg.SyslogProtocol, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'syslog-protocol': %w", ival, err) + } + } + + if ival, ok := cfgmap["syslog-address"]; ok { + var err error + cfg.SyslogAddress, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'syslog-address': %w", ival, err) + } + } + + if ival, ok := cfgmap["advanced-cookies-samesite"]; ok { + var err error + cfg.Advanced.CookiesSamesite, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'advanced-cookies-samesite': %w", ival, err) + } + } + + if ival, ok := cfgmap["advanced-sender-multiplier"]; ok { + var err error + cfg.Advanced.SenderMultiplier, err = cast.ToIntE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> int for 'advanced-sender-multiplier': %w", ival, err) + } + } + + if ival, ok := cfgmap["advanced-csp-extra-uris"]; ok { + var err error + cfg.Advanced.CSPExtraURIs, err = toStringSlice(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> []string for 'advanced-csp-extra-uris': %w", ival, err) + } + } + + if ival, ok := cfgmap["advanced-header-filter-mode"]; ok { + var err error + cfg.Advanced.HeaderFilterMode, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'advanced-header-filter-mode': %w", ival, err) + } + } + + if ival, ok := cfgmap["advanced-scraper-deterrence"]; ok { + var err error + cfg.Advanced.ScraperDeterrence, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'advanced-scraper-deterrence': %w", ival, err) + } + } + + if ival, ok := cfgmap["advanced-rate-limit-requests"]; ok { + var err error + cfg.Advanced.RateLimit.Requests, err = cast.ToIntE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> int for 'advanced-rate-limit-requests': %w", ival, err) + } + } + + if ival, ok := cfgmap["advanced-rate-limit-exceptions"]; ok { + t, err := toStringSlice(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> []string for 'advanced-rate-limit-exceptions': %w", ival, err) + } + cfg.Advanced.RateLimit.Exceptions = IPPrefixes{} + for _, in := range t { + if err := cfg.Advanced.RateLimit.Exceptions.Set(in); err != nil { + return fmt.Errorf("error parsing %#v for 'advanced-rate-limit-exceptions': %w", ival, err) + } + } + } + + if ival, ok := cfgmap["advanced-throttling-multiplier"]; ok { + var err error + cfg.Advanced.Throttling.Multiplier, err = cast.ToIntE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> int for 'advanced-throttling-multiplier': %w", ival, err) + } + } + + if ival, ok := cfgmap["advanced-throttling-retry-after"]; ok { + var err error + cfg.Advanced.Throttling.RetryAfter, err = cast.ToDurationE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> time.Duration for 'advanced-throttling-retry-after': %w", ival, err) + } + } + + if ival, ok := cfgmap["http-client-allow-ips"]; ok { + var err error + cfg.HTTPClient.AllowIPs, err = toStringSlice(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> []string for 'http-client-allow-ips': %w", ival, err) + } + } + + if ival, ok := cfgmap["http-client-block-ips"]; ok { + var err error + cfg.HTTPClient.BlockIPs, err = toStringSlice(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> []string for 'http-client-block-ips': %w", ival, err) + } + } + + if ival, ok := cfgmap["http-client-timeout"]; ok { + var err error + cfg.HTTPClient.Timeout, err = cast.ToDurationE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> time.Duration for 'http-client-timeout': %w", ival, err) + } + } + + if ival, ok := cfgmap["http-client-tls-insecure-skip-verify"]; ok { + var err error + cfg.HTTPClient.TLSInsecureSkipVerify, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'http-client-tls-insecure-skip-verify': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-memory-target"]; ok { + t, err := cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'cache-memory-target': %w", ival, err) + } + cfg.Cache.MemoryTarget = 0x0 + if err := cfg.Cache.MemoryTarget.Set(t); err != nil { + return fmt.Errorf("error parsing %#v for 'cache-memory-target': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-account-mem-ratio"]; ok { + var err error + cfg.Cache.AccountMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-account-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-account-note-mem-ratio"]; ok { + var err error + cfg.Cache.AccountNoteMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-account-note-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-account-settings-mem-ratio"]; ok { + var err error + cfg.Cache.AccountSettingsMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-account-settings-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-account-stats-mem-ratio"]; ok { + var err error + cfg.Cache.AccountStatsMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-account-stats-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-application-mem-ratio"]; ok { + var err error + cfg.Cache.ApplicationMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-application-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-block-mem-ratio"]; ok { + var err error + cfg.Cache.BlockMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-block-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-block-ids-mem-ratio"]; ok { + var err error + cfg.Cache.BlockIDsMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-block-ids-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-boost-of-ids-mem-ratio"]; ok { + var err error + cfg.Cache.BoostOfIDsMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-boost-of-ids-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-client-mem-ratio"]; ok { + var err error + cfg.Cache.ClientMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-client-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-conversation-mem-ratio"]; ok { + var err error + cfg.Cache.ConversationMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-conversation-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-conversation-last-status-ids-mem-ratio"]; ok { + var err error + cfg.Cache.ConversationLastStatusIDsMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-conversation-last-status-ids-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-domain-permission-draft-mem-ratio"]; ok { + var err error + cfg.Cache.DomainPermissionDraftMemRation, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-domain-permission-draft-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-domain-permission-subscription-mem-ratio"]; ok { + var err error + cfg.Cache.DomainPermissionSubscriptionMemRation, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-domain-permission-subscription-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-emoji-mem-ratio"]; ok { + var err error + cfg.Cache.EmojiMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-emoji-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-emoji-category-mem-ratio"]; ok { + var err error + cfg.Cache.EmojiCategoryMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-emoji-category-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-filter-mem-ratio"]; ok { + var err error + cfg.Cache.FilterMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-filter-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-filter-keyword-mem-ratio"]; ok { + var err error + cfg.Cache.FilterKeywordMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-filter-keyword-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-filter-status-mem-ratio"]; ok { + var err error + cfg.Cache.FilterStatusMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-filter-status-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-follow-mem-ratio"]; ok { + var err error + cfg.Cache.FollowMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-follow-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-follow-ids-mem-ratio"]; ok { + var err error + cfg.Cache.FollowIDsMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-follow-ids-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-follow-request-mem-ratio"]; ok { + var err error + cfg.Cache.FollowRequestMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-follow-request-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-follow-request-ids-mem-ratio"]; ok { + var err error + cfg.Cache.FollowRequestIDsMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-follow-request-ids-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-following-tag-ids-mem-ratio"]; ok { + var err error + cfg.Cache.FollowingTagIDsMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-following-tag-ids-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-in-reply-to-ids-mem-ratio"]; ok { + var err error + cfg.Cache.InReplyToIDsMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-in-reply-to-ids-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-instance-mem-ratio"]; ok { + var err error + cfg.Cache.InstanceMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-instance-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-interaction-request-mem-ratio"]; ok { + var err error + cfg.Cache.InteractionRequestMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-interaction-request-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-list-mem-ratio"]; ok { + var err error + cfg.Cache.ListMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-list-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-list-ids-mem-ratio"]; ok { + var err error + cfg.Cache.ListIDsMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-list-ids-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-listed-ids-mem-ratio"]; ok { + var err error + cfg.Cache.ListedIDsMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-listed-ids-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-marker-mem-ratio"]; ok { + var err error + cfg.Cache.MarkerMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-marker-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-media-mem-ratio"]; ok { + var err error + cfg.Cache.MediaMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-media-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-mention-mem-ratio"]; ok { + var err error + cfg.Cache.MentionMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-mention-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-move-mem-ratio"]; ok { + var err error + cfg.Cache.MoveMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-move-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-notification-mem-ratio"]; ok { + var err error + cfg.Cache.NotificationMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-notification-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-poll-mem-ratio"]; ok { + var err error + cfg.Cache.PollMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-poll-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-poll-vote-mem-ratio"]; ok { + var err error + cfg.Cache.PollVoteMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-poll-vote-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-poll-vote-ids-mem-ratio"]; ok { + var err error + cfg.Cache.PollVoteIDsMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-poll-vote-ids-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-report-mem-ratio"]; ok { + var err error + cfg.Cache.ReportMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-report-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-sin-bin-status-mem-ratio"]; ok { + var err error + cfg.Cache.SinBinStatusMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-sin-bin-status-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-status-mem-ratio"]; ok { + var err error + cfg.Cache.StatusMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-status-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-status-bookmark-mem-ratio"]; ok { + var err error + cfg.Cache.StatusBookmarkMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-status-bookmark-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-status-bookmark-ids-mem-ratio"]; ok { + var err error + cfg.Cache.StatusBookmarkIDsMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-status-bookmark-ids-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-status-edit-mem-ratio"]; ok { + var err error + cfg.Cache.StatusEditMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-status-edit-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-status-fave-mem-ratio"]; ok { + var err error + cfg.Cache.StatusFaveMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-status-fave-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-status-fave-ids-mem-ratio"]; ok { + var err error + cfg.Cache.StatusFaveIDsMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-status-fave-ids-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-tag-mem-ratio"]; ok { + var err error + cfg.Cache.TagMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-tag-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-thread-mute-mem-ratio"]; ok { + var err error + cfg.Cache.ThreadMuteMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-thread-mute-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-token-mem-ratio"]; ok { + var err error + cfg.Cache.TokenMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-token-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-tombstone-mem-ratio"]; ok { + var err error + cfg.Cache.TombstoneMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-tombstone-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-user-mem-ratio"]; ok { + var err error + cfg.Cache.UserMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-user-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-user-mute-mem-ratio"]; ok { + var err error + cfg.Cache.UserMuteMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-user-mute-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-user-mute-ids-mem-ratio"]; ok { + var err error + cfg.Cache.UserMuteIDsMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-user-mute-ids-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-webfinger-mem-ratio"]; ok { + var err error + cfg.Cache.WebfingerMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-webfinger-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-web-push-subscription-mem-ratio"]; ok { + var err error + cfg.Cache.WebPushSubscriptionMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-web-push-subscription-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-web-push-subscription-ids-mem-ratio"]; ok { + var err error + cfg.Cache.WebPushSubscriptionIDsMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-web-push-subscription-ids-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["cache-visibility-mem-ratio"]; ok { + var err error + cfg.Cache.VisibilityMemRatio, err = cast.ToFloat64E(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> float64 for 'cache-visibility-mem-ratio': %w", ival, err) + } + } + + if ival, ok := cfgmap["username"]; ok { + var err error + cfg.AdminAccountUsername, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'username': %w", ival, err) + } + } + + if ival, ok := cfgmap["email"]; ok { + var err error + cfg.AdminAccountEmail, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'email': %w", ival, err) + } + } + + if ival, ok := cfgmap["password"]; ok { + var err error + cfg.AdminAccountPassword, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'password': %w", ival, err) + } + } + + if ival, ok := cfgmap["path"]; ok { + var err error + cfg.AdminTransPath, err = cast.ToStringE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> string for 'path': %w", ival, err) + } + } + + if ival, ok := cfgmap["dry-run"]; ok { + var err error + cfg.AdminMediaPruneDryRun, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'dry-run': %w", ival, err) + } + } + + if ival, ok := cfgmap["local-only"]; ok { + var err error + cfg.AdminMediaListLocalOnly, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'local-only': %w", ival, err) + } + } + + if ival, ok := cfgmap["remote-only"]; ok { + var err error + cfg.AdminMediaListRemoteOnly, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'remote-only': %w", ival, err) + } + } + + return nil +} + +// LogLevelFlag returns the flag name for the 'LogLevel' field +func LogLevelFlag() string { return "log-level" } + // GetLogLevel safely fetches the Configuration value for state's 'LogLevel' field func (st *ConfigState) GetLogLevel() (v string) { st.mutex.RLock() @@ -41,15 +1891,15 @@ func (st *ConfigState) SetLogLevel(v string) { st.reloadToViper() } -// LogLevelFlag returns the flag name for the 'LogLevel' field -func LogLevelFlag() string { return "log-level" } - // GetLogLevel safely fetches the value for global configuration 'LogLevel' field func GetLogLevel() string { return global.GetLogLevel() } // SetLogLevel safely sets the value for global configuration 'LogLevel' field func SetLogLevel(v string) { global.SetLogLevel(v) } +// LogTimestampFormatFlag returns the flag name for the 'LogTimestampFormat' field +func LogTimestampFormatFlag() string { return "log-timestamp-format" } + // GetLogTimestampFormat safely fetches the Configuration value for state's 'LogTimestampFormat' field func (st *ConfigState) GetLogTimestampFormat() (v string) { st.mutex.RLock() @@ -66,15 +1916,15 @@ func (st *ConfigState) SetLogTimestampFormat(v string) { st.reloadToViper() } -// LogTimestampFormatFlag returns the flag name for the 'LogTimestampFormat' field -func LogTimestampFormatFlag() string { return "log-timestamp-format" } - // GetLogTimestampFormat safely fetches the value for global configuration 'LogTimestampFormat' field func GetLogTimestampFormat() string { return global.GetLogTimestampFormat() } // SetLogTimestampFormat safely sets the value for global configuration 'LogTimestampFormat' field func SetLogTimestampFormat(v string) { global.SetLogTimestampFormat(v) } +// LogDbQueriesFlag returns the flag name for the 'LogDbQueries' field +func LogDbQueriesFlag() string { return "log-db-queries" } + // GetLogDbQueries safely fetches the Configuration value for state's 'LogDbQueries' field func (st *ConfigState) GetLogDbQueries() (v bool) { st.mutex.RLock() @@ -91,15 +1941,15 @@ func (st *ConfigState) SetLogDbQueries(v bool) { st.reloadToViper() } -// LogDbQueriesFlag returns the flag name for the 'LogDbQueries' field -func LogDbQueriesFlag() string { return "log-db-queries" } - // GetLogDbQueries safely fetches the value for global configuration 'LogDbQueries' field func GetLogDbQueries() bool { return global.GetLogDbQueries() } // SetLogDbQueries safely sets the value for global configuration 'LogDbQueries' field func SetLogDbQueries(v bool) { global.SetLogDbQueries(v) } +// LogClientIPFlag returns the flag name for the 'LogClientIP' field +func LogClientIPFlag() string { return "log-client-ip" } + // GetLogClientIP safely fetches the Configuration value for state's 'LogClientIP' field func (st *ConfigState) GetLogClientIP() (v bool) { st.mutex.RLock() @@ -116,15 +1966,65 @@ func (st *ConfigState) SetLogClientIP(v bool) { st.reloadToViper() } -// LogClientIPFlag returns the flag name for the 'LogClientIP' field -func LogClientIPFlag() string { return "log-client-ip" } - // GetLogClientIP safely fetches the value for global configuration 'LogClientIP' field func GetLogClientIP() bool { return global.GetLogClientIP() } // SetLogClientIP safely sets the value for global configuration 'LogClientIP' field func SetLogClientIP(v bool) { global.SetLogClientIP(v) } +// RequestIDHeaderFlag returns the flag name for the 'RequestIDHeader' field +func RequestIDHeaderFlag() string { return "request-id-header" } + +// GetRequestIDHeader safely fetches the Configuration value for state's 'RequestIDHeader' field +func (st *ConfigState) GetRequestIDHeader() (v string) { + st.mutex.RLock() + v = st.config.RequestIDHeader + st.mutex.RUnlock() + return +} + +// SetRequestIDHeader safely sets the Configuration value for state's 'RequestIDHeader' field +func (st *ConfigState) SetRequestIDHeader(v string) { + st.mutex.Lock() + defer st.mutex.Unlock() + st.config.RequestIDHeader = v + st.reloadToViper() +} + +// GetRequestIDHeader safely fetches the value for global configuration 'RequestIDHeader' field +func GetRequestIDHeader() string { return global.GetRequestIDHeader() } + +// SetRequestIDHeader safely sets the value for global configuration 'RequestIDHeader' field +func SetRequestIDHeader(v string) { global.SetRequestIDHeader(v) } + +// ConfigPathFlag returns the flag name for the 'ConfigPath' field +func ConfigPathFlag() string { return "config-path" } + +// GetConfigPath safely fetches the Configuration value for state's 'ConfigPath' field +func (st *ConfigState) GetConfigPath() (v string) { + st.mutex.RLock() + v = st.config.ConfigPath + st.mutex.RUnlock() + return +} + +// SetConfigPath safely sets the Configuration value for state's 'ConfigPath' field +func (st *ConfigState) SetConfigPath(v string) { + st.mutex.Lock() + defer st.mutex.Unlock() + st.config.ConfigPath = v + st.reloadToViper() +} + +// GetConfigPath safely fetches the value for global configuration 'ConfigPath' field +func GetConfigPath() string { return global.GetConfigPath() } + +// SetConfigPath safely sets the value for global configuration 'ConfigPath' field +func SetConfigPath(v string) { global.SetConfigPath(v) } + +// ApplicationNameFlag returns the flag name for the 'ApplicationName' field +func ApplicationNameFlag() string { return "application-name" } + // GetApplicationName safely fetches the Configuration value for state's 'ApplicationName' field func (st *ConfigState) GetApplicationName() (v string) { st.mutex.RLock() @@ -141,15 +2041,15 @@ func (st *ConfigState) SetApplicationName(v string) { st.reloadToViper() } -// ApplicationNameFlag returns the flag name for the 'ApplicationName' field -func ApplicationNameFlag() string { return "application-name" } - // GetApplicationName safely fetches the value for global configuration 'ApplicationName' field func GetApplicationName() string { return global.GetApplicationName() } // SetApplicationName safely sets the value for global configuration 'ApplicationName' field func SetApplicationName(v string) { global.SetApplicationName(v) } +// LandingPageUserFlag returns the flag name for the 'LandingPageUser' field +func LandingPageUserFlag() string { return "landing-page-user" } + // GetLandingPageUser safely fetches the Configuration value for state's 'LandingPageUser' field func (st *ConfigState) GetLandingPageUser() (v string) { st.mutex.RLock() @@ -166,39 +2066,14 @@ func (st *ConfigState) SetLandingPageUser(v string) { st.reloadToViper() } -// LandingPageUserFlag returns the flag name for the 'LandingPageUser' field -func LandingPageUserFlag() string { return "landing-page-user" } - // GetLandingPageUser safely fetches the value for global configuration 'LandingPageUser' field func GetLandingPageUser() string { return global.GetLandingPageUser() } // SetLandingPageUser safely sets the value for global configuration 'LandingPageUser' field func SetLandingPageUser(v string) { global.SetLandingPageUser(v) } -// GetConfigPath safely fetches the Configuration value for state's 'ConfigPath' field -func (st *ConfigState) GetConfigPath() (v string) { - st.mutex.RLock() - v = st.config.ConfigPath - st.mutex.RUnlock() - return -} - -// SetConfigPath safely sets the Configuration value for state's 'ConfigPath' field -func (st *ConfigState) SetConfigPath(v string) { - st.mutex.Lock() - defer st.mutex.Unlock() - st.config.ConfigPath = v - st.reloadToViper() -} - -// ConfigPathFlag returns the flag name for the 'ConfigPath' field -func ConfigPathFlag() string { return "config-path" } - -// GetConfigPath safely fetches the value for global configuration 'ConfigPath' field -func GetConfigPath() string { return global.GetConfigPath() } - -// SetConfigPath safely sets the value for global configuration 'ConfigPath' field -func SetConfigPath(v string) { global.SetConfigPath(v) } +// HostFlag returns the flag name for the 'Host' field +func HostFlag() string { return "host" } // GetHost safely fetches the Configuration value for state's 'Host' field func (st *ConfigState) GetHost() (v string) { @@ -216,15 +2091,15 @@ func (st *ConfigState) SetHost(v string) { st.reloadToViper() } -// HostFlag returns the flag name for the 'Host' field -func HostFlag() string { return "host" } - // GetHost safely fetches the value for global configuration 'Host' field func GetHost() string { return global.GetHost() } // SetHost safely sets the value for global configuration 'Host' field func SetHost(v string) { global.SetHost(v) } +// AccountDomainFlag returns the flag name for the 'AccountDomain' field +func AccountDomainFlag() string { return "account-domain" } + // GetAccountDomain safely fetches the Configuration value for state's 'AccountDomain' field func (st *ConfigState) GetAccountDomain() (v string) { st.mutex.RLock() @@ -241,15 +2116,15 @@ func (st *ConfigState) SetAccountDomain(v string) { st.reloadToViper() } -// AccountDomainFlag returns the flag name for the 'AccountDomain' field -func AccountDomainFlag() string { return "account-domain" } - // GetAccountDomain safely fetches the value for global configuration 'AccountDomain' field func GetAccountDomain() string { return global.GetAccountDomain() } // SetAccountDomain safely sets the value for global configuration 'AccountDomain' field func SetAccountDomain(v string) { global.SetAccountDomain(v) } +// ProtocolFlag returns the flag name for the 'Protocol' field +func ProtocolFlag() string { return "protocol" } + // GetProtocol safely fetches the Configuration value for state's 'Protocol' field func (st *ConfigState) GetProtocol() (v string) { st.mutex.RLock() @@ -266,15 +2141,15 @@ func (st *ConfigState) SetProtocol(v string) { st.reloadToViper() } -// ProtocolFlag returns the flag name for the 'Protocol' field -func ProtocolFlag() string { return "protocol" } - // GetProtocol safely fetches the value for global configuration 'Protocol' field func GetProtocol() string { return global.GetProtocol() } // SetProtocol safely sets the value for global configuration 'Protocol' field func SetProtocol(v string) { global.SetProtocol(v) } +// BindAddressFlag returns the flag name for the 'BindAddress' field +func BindAddressFlag() string { return "bind-address" } + // GetBindAddress safely fetches the Configuration value for state's 'BindAddress' field func (st *ConfigState) GetBindAddress() (v string) { st.mutex.RLock() @@ -291,15 +2166,15 @@ func (st *ConfigState) SetBindAddress(v string) { st.reloadToViper() } -// BindAddressFlag returns the flag name for the 'BindAddress' field -func BindAddressFlag() string { return "bind-address" } - // GetBindAddress safely fetches the value for global configuration 'BindAddress' field func GetBindAddress() string { return global.GetBindAddress() } // SetBindAddress safely sets the value for global configuration 'BindAddress' field func SetBindAddress(v string) { global.SetBindAddress(v) } +// PortFlag returns the flag name for the 'Port' field +func PortFlag() string { return "port" } + // GetPort safely fetches the Configuration value for state's 'Port' field func (st *ConfigState) GetPort() (v int) { st.mutex.RLock() @@ -316,15 +2191,15 @@ func (st *ConfigState) SetPort(v int) { st.reloadToViper() } -// PortFlag returns the flag name for the 'Port' field -func PortFlag() string { return "port" } - // GetPort safely fetches the value for global configuration 'Port' field func GetPort() int { return global.GetPort() } // SetPort safely sets the value for global configuration 'Port' field func SetPort(v int) { global.SetPort(v) } +// TrustedProxiesFlag returns the flag name for the 'TrustedProxies' field +func TrustedProxiesFlag() string { return "trusted-proxies" } + // GetTrustedProxies safely fetches the Configuration value for state's 'TrustedProxies' field func (st *ConfigState) GetTrustedProxies() (v []string) { st.mutex.RLock() @@ -341,15 +2216,15 @@ func (st *ConfigState) SetTrustedProxies(v []string) { st.reloadToViper() } -// TrustedProxiesFlag returns the flag name for the 'TrustedProxies' field -func TrustedProxiesFlag() string { return "trusted-proxies" } - // GetTrustedProxies safely fetches the value for global configuration 'TrustedProxies' field func GetTrustedProxies() []string { return global.GetTrustedProxies() } // SetTrustedProxies safely sets the value for global configuration 'TrustedProxies' field func SetTrustedProxies(v []string) { global.SetTrustedProxies(v) } +// SoftwareVersionFlag returns the flag name for the 'SoftwareVersion' field +func SoftwareVersionFlag() string { return "software-version" } + // GetSoftwareVersion safely fetches the Configuration value for state's 'SoftwareVersion' field func (st *ConfigState) GetSoftwareVersion() (v string) { st.mutex.RLock() @@ -366,15 +2241,15 @@ func (st *ConfigState) SetSoftwareVersion(v string) { st.reloadToViper() } -// SoftwareVersionFlag returns the flag name for the 'SoftwareVersion' field -func SoftwareVersionFlag() string { return "software-version" } - // GetSoftwareVersion safely fetches the value for global configuration 'SoftwareVersion' field func GetSoftwareVersion() string { return global.GetSoftwareVersion() } // SetSoftwareVersion safely sets the value for global configuration 'SoftwareVersion' field func SetSoftwareVersion(v string) { global.SetSoftwareVersion(v) } +// DbTypeFlag returns the flag name for the 'DbType' field +func DbTypeFlag() string { return "db-type" } + // GetDbType safely fetches the Configuration value for state's 'DbType' field func (st *ConfigState) GetDbType() (v string) { st.mutex.RLock() @@ -391,15 +2266,15 @@ func (st *ConfigState) SetDbType(v string) { st.reloadToViper() } -// DbTypeFlag returns the flag name for the 'DbType' field -func DbTypeFlag() string { return "db-type" } - // GetDbType safely fetches the value for global configuration 'DbType' field func GetDbType() string { return global.GetDbType() } // SetDbType safely sets the value for global configuration 'DbType' field func SetDbType(v string) { global.SetDbType(v) } +// DbAddressFlag returns the flag name for the 'DbAddress' field +func DbAddressFlag() string { return "db-address" } + // GetDbAddress safely fetches the Configuration value for state's 'DbAddress' field func (st *ConfigState) GetDbAddress() (v string) { st.mutex.RLock() @@ -416,15 +2291,15 @@ func (st *ConfigState) SetDbAddress(v string) { st.reloadToViper() } -// DbAddressFlag returns the flag name for the 'DbAddress' field -func DbAddressFlag() string { return "db-address" } - // GetDbAddress safely fetches the value for global configuration 'DbAddress' field func GetDbAddress() string { return global.GetDbAddress() } // SetDbAddress safely sets the value for global configuration 'DbAddress' field func SetDbAddress(v string) { global.SetDbAddress(v) } +// DbPortFlag returns the flag name for the 'DbPort' field +func DbPortFlag() string { return "db-port" } + // GetDbPort safely fetches the Configuration value for state's 'DbPort' field func (st *ConfigState) GetDbPort() (v int) { st.mutex.RLock() @@ -441,15 +2316,15 @@ func (st *ConfigState) SetDbPort(v int) { st.reloadToViper() } -// DbPortFlag returns the flag name for the 'DbPort' field -func DbPortFlag() string { return "db-port" } - // GetDbPort safely fetches the value for global configuration 'DbPort' field func GetDbPort() int { return global.GetDbPort() } // SetDbPort safely sets the value for global configuration 'DbPort' field func SetDbPort(v int) { global.SetDbPort(v) } +// DbUserFlag returns the flag name for the 'DbUser' field +func DbUserFlag() string { return "db-user" } + // GetDbUser safely fetches the Configuration value for state's 'DbUser' field func (st *ConfigState) GetDbUser() (v string) { st.mutex.RLock() @@ -466,15 +2341,15 @@ func (st *ConfigState) SetDbUser(v string) { st.reloadToViper() } -// DbUserFlag returns the flag name for the 'DbUser' field -func DbUserFlag() string { return "db-user" } - // GetDbUser safely fetches the value for global configuration 'DbUser' field func GetDbUser() string { return global.GetDbUser() } // SetDbUser safely sets the value for global configuration 'DbUser' field func SetDbUser(v string) { global.SetDbUser(v) } +// DbPasswordFlag returns the flag name for the 'DbPassword' field +func DbPasswordFlag() string { return "db-password" } + // GetDbPassword safely fetches the Configuration value for state's 'DbPassword' field func (st *ConfigState) GetDbPassword() (v string) { st.mutex.RLock() @@ -491,15 +2366,15 @@ func (st *ConfigState) SetDbPassword(v string) { st.reloadToViper() } -// DbPasswordFlag returns the flag name for the 'DbPassword' field -func DbPasswordFlag() string { return "db-password" } - // GetDbPassword safely fetches the value for global configuration 'DbPassword' field func GetDbPassword() string { return global.GetDbPassword() } // SetDbPassword safely sets the value for global configuration 'DbPassword' field func SetDbPassword(v string) { global.SetDbPassword(v) } +// DbDatabaseFlag returns the flag name for the 'DbDatabase' field +func DbDatabaseFlag() string { return "db-database" } + // GetDbDatabase safely fetches the Configuration value for state's 'DbDatabase' field func (st *ConfigState) GetDbDatabase() (v string) { st.mutex.RLock() @@ -516,15 +2391,15 @@ func (st *ConfigState) SetDbDatabase(v string) { st.reloadToViper() } -// DbDatabaseFlag returns the flag name for the 'DbDatabase' field -func DbDatabaseFlag() string { return "db-database" } - // GetDbDatabase safely fetches the value for global configuration 'DbDatabase' field func GetDbDatabase() string { return global.GetDbDatabase() } // SetDbDatabase safely sets the value for global configuration 'DbDatabase' field func SetDbDatabase(v string) { global.SetDbDatabase(v) } +// DbTLSModeFlag returns the flag name for the 'DbTLSMode' field +func DbTLSModeFlag() string { return "db-tls-mode" } + // GetDbTLSMode safely fetches the Configuration value for state's 'DbTLSMode' field func (st *ConfigState) GetDbTLSMode() (v string) { st.mutex.RLock() @@ -541,15 +2416,15 @@ func (st *ConfigState) SetDbTLSMode(v string) { st.reloadToViper() } -// DbTLSModeFlag returns the flag name for the 'DbTLSMode' field -func DbTLSModeFlag() string { return "db-tls-mode" } - // GetDbTLSMode safely fetches the value for global configuration 'DbTLSMode' field func GetDbTLSMode() string { return global.GetDbTLSMode() } // SetDbTLSMode safely sets the value for global configuration 'DbTLSMode' field func SetDbTLSMode(v string) { global.SetDbTLSMode(v) } +// DbTLSCACertFlag returns the flag name for the 'DbTLSCACert' field +func DbTLSCACertFlag() string { return "db-tls-ca-cert" } + // GetDbTLSCACert safely fetches the Configuration value for state's 'DbTLSCACert' field func (st *ConfigState) GetDbTLSCACert() (v string) { st.mutex.RLock() @@ -566,15 +2441,15 @@ func (st *ConfigState) SetDbTLSCACert(v string) { st.reloadToViper() } -// DbTLSCACertFlag returns the flag name for the 'DbTLSCACert' field -func DbTLSCACertFlag() string { return "db-tls-ca-cert" } - // GetDbTLSCACert safely fetches the value for global configuration 'DbTLSCACert' field func GetDbTLSCACert() string { return global.GetDbTLSCACert() } // SetDbTLSCACert safely sets the value for global configuration 'DbTLSCACert' field func SetDbTLSCACert(v string) { global.SetDbTLSCACert(v) } +// DbMaxOpenConnsMultiplierFlag returns the flag name for the 'DbMaxOpenConnsMultiplier' field +func DbMaxOpenConnsMultiplierFlag() string { return "db-max-open-conns-multiplier" } + // GetDbMaxOpenConnsMultiplier safely fetches the Configuration value for state's 'DbMaxOpenConnsMultiplier' field func (st *ConfigState) GetDbMaxOpenConnsMultiplier() (v int) { st.mutex.RLock() @@ -591,15 +2466,15 @@ func (st *ConfigState) SetDbMaxOpenConnsMultiplier(v int) { st.reloadToViper() } -// DbMaxOpenConnsMultiplierFlag returns the flag name for the 'DbMaxOpenConnsMultiplier' field -func DbMaxOpenConnsMultiplierFlag() string { return "db-max-open-conns-multiplier" } - // GetDbMaxOpenConnsMultiplier safely fetches the value for global configuration 'DbMaxOpenConnsMultiplier' field func GetDbMaxOpenConnsMultiplier() int { return global.GetDbMaxOpenConnsMultiplier() } // SetDbMaxOpenConnsMultiplier safely sets the value for global configuration 'DbMaxOpenConnsMultiplier' field func SetDbMaxOpenConnsMultiplier(v int) { global.SetDbMaxOpenConnsMultiplier(v) } +// DbSqliteJournalModeFlag returns the flag name for the 'DbSqliteJournalMode' field +func DbSqliteJournalModeFlag() string { return "db-sqlite-journal-mode" } + // GetDbSqliteJournalMode safely fetches the Configuration value for state's 'DbSqliteJournalMode' field func (st *ConfigState) GetDbSqliteJournalMode() (v string) { st.mutex.RLock() @@ -616,15 +2491,15 @@ func (st *ConfigState) SetDbSqliteJournalMode(v string) { st.reloadToViper() } -// DbSqliteJournalModeFlag returns the flag name for the 'DbSqliteJournalMode' field -func DbSqliteJournalModeFlag() string { return "db-sqlite-journal-mode" } - // GetDbSqliteJournalMode safely fetches the value for global configuration 'DbSqliteJournalMode' field func GetDbSqliteJournalMode() string { return global.GetDbSqliteJournalMode() } // SetDbSqliteJournalMode safely sets the value for global configuration 'DbSqliteJournalMode' field func SetDbSqliteJournalMode(v string) { global.SetDbSqliteJournalMode(v) } +// DbSqliteSynchronousFlag returns the flag name for the 'DbSqliteSynchronous' field +func DbSqliteSynchronousFlag() string { return "db-sqlite-synchronous" } + // GetDbSqliteSynchronous safely fetches the Configuration value for state's 'DbSqliteSynchronous' field func (st *ConfigState) GetDbSqliteSynchronous() (v string) { st.mutex.RLock() @@ -641,15 +2516,15 @@ func (st *ConfigState) SetDbSqliteSynchronous(v string) { st.reloadToViper() } -// DbSqliteSynchronousFlag returns the flag name for the 'DbSqliteSynchronous' field -func DbSqliteSynchronousFlag() string { return "db-sqlite-synchronous" } - // GetDbSqliteSynchronous safely fetches the value for global configuration 'DbSqliteSynchronous' field func GetDbSqliteSynchronous() string { return global.GetDbSqliteSynchronous() } // SetDbSqliteSynchronous safely sets the value for global configuration 'DbSqliteSynchronous' field func SetDbSqliteSynchronous(v string) { global.SetDbSqliteSynchronous(v) } +// DbSqliteCacheSizeFlag returns the flag name for the 'DbSqliteCacheSize' field +func DbSqliteCacheSizeFlag() string { return "db-sqlite-cache-size" } + // GetDbSqliteCacheSize safely fetches the Configuration value for state's 'DbSqliteCacheSize' field func (st *ConfigState) GetDbSqliteCacheSize() (v bytesize.Size) { st.mutex.RLock() @@ -666,15 +2541,15 @@ func (st *ConfigState) SetDbSqliteCacheSize(v bytesize.Size) { st.reloadToViper() } -// DbSqliteCacheSizeFlag returns the flag name for the 'DbSqliteCacheSize' field -func DbSqliteCacheSizeFlag() string { return "db-sqlite-cache-size" } - // GetDbSqliteCacheSize safely fetches the value for global configuration 'DbSqliteCacheSize' field func GetDbSqliteCacheSize() bytesize.Size { return global.GetDbSqliteCacheSize() } // SetDbSqliteCacheSize safely sets the value for global configuration 'DbSqliteCacheSize' field func SetDbSqliteCacheSize(v bytesize.Size) { global.SetDbSqliteCacheSize(v) } +// DbSqliteBusyTimeoutFlag returns the flag name for the 'DbSqliteBusyTimeout' field +func DbSqliteBusyTimeoutFlag() string { return "db-sqlite-busy-timeout" } + // GetDbSqliteBusyTimeout safely fetches the Configuration value for state's 'DbSqliteBusyTimeout' field func (st *ConfigState) GetDbSqliteBusyTimeout() (v time.Duration) { st.mutex.RLock() @@ -691,15 +2566,15 @@ func (st *ConfigState) SetDbSqliteBusyTimeout(v time.Duration) { st.reloadToViper() } -// DbSqliteBusyTimeoutFlag returns the flag name for the 'DbSqliteBusyTimeout' field -func DbSqliteBusyTimeoutFlag() string { return "db-sqlite-busy-timeout" } - // GetDbSqliteBusyTimeout safely fetches the value for global configuration 'DbSqliteBusyTimeout' field func GetDbSqliteBusyTimeout() time.Duration { return global.GetDbSqliteBusyTimeout() } // SetDbSqliteBusyTimeout safely sets the value for global configuration 'DbSqliteBusyTimeout' field func SetDbSqliteBusyTimeout(v time.Duration) { global.SetDbSqliteBusyTimeout(v) } +// DbPostgresConnectionStringFlag returns the flag name for the 'DbPostgresConnectionString' field +func DbPostgresConnectionStringFlag() string { return "db-postgres-connection-string" } + // GetDbPostgresConnectionString safely fetches the Configuration value for state's 'DbPostgresConnectionString' field func (st *ConfigState) GetDbPostgresConnectionString() (v string) { st.mutex.RLock() @@ -716,15 +2591,15 @@ func (st *ConfigState) SetDbPostgresConnectionString(v string) { st.reloadToViper() } -// DbPostgresConnectionStringFlag returns the flag name for the 'DbPostgresConnectionString' field -func DbPostgresConnectionStringFlag() string { return "db-postgres-connection-string" } - // GetDbPostgresConnectionString safely fetches the value for global configuration 'DbPostgresConnectionString' field func GetDbPostgresConnectionString() string { return global.GetDbPostgresConnectionString() } // SetDbPostgresConnectionString safely sets the value for global configuration 'DbPostgresConnectionString' field func SetDbPostgresConnectionString(v string) { global.SetDbPostgresConnectionString(v) } +// WebTemplateBaseDirFlag returns the flag name for the 'WebTemplateBaseDir' field +func WebTemplateBaseDirFlag() string { return "web-template-base-dir" } + // GetWebTemplateBaseDir safely fetches the Configuration value for state's 'WebTemplateBaseDir' field func (st *ConfigState) GetWebTemplateBaseDir() (v string) { st.mutex.RLock() @@ -741,15 +2616,15 @@ func (st *ConfigState) SetWebTemplateBaseDir(v string) { st.reloadToViper() } -// WebTemplateBaseDirFlag returns the flag name for the 'WebTemplateBaseDir' field -func WebTemplateBaseDirFlag() string { return "web-template-base-dir" } - // GetWebTemplateBaseDir safely fetches the value for global configuration 'WebTemplateBaseDir' field func GetWebTemplateBaseDir() string { return global.GetWebTemplateBaseDir() } // SetWebTemplateBaseDir safely sets the value for global configuration 'WebTemplateBaseDir' field func SetWebTemplateBaseDir(v string) { global.SetWebTemplateBaseDir(v) } +// WebAssetBaseDirFlag returns the flag name for the 'WebAssetBaseDir' field +func WebAssetBaseDirFlag() string { return "web-asset-base-dir" } + // GetWebAssetBaseDir safely fetches the Configuration value for state's 'WebAssetBaseDir' field func (st *ConfigState) GetWebAssetBaseDir() (v string) { st.mutex.RLock() @@ -766,15 +2641,15 @@ func (st *ConfigState) SetWebAssetBaseDir(v string) { st.reloadToViper() } -// WebAssetBaseDirFlag returns the flag name for the 'WebAssetBaseDir' field -func WebAssetBaseDirFlag() string { return "web-asset-base-dir" } - // GetWebAssetBaseDir safely fetches the value for global configuration 'WebAssetBaseDir' field func GetWebAssetBaseDir() string { return global.GetWebAssetBaseDir() } // SetWebAssetBaseDir safely sets the value for global configuration 'WebAssetBaseDir' field func SetWebAssetBaseDir(v string) { global.SetWebAssetBaseDir(v) } +// InstanceFederationModeFlag returns the flag name for the 'InstanceFederationMode' field +func InstanceFederationModeFlag() string { return "instance-federation-mode" } + // GetInstanceFederationMode safely fetches the Configuration value for state's 'InstanceFederationMode' field func (st *ConfigState) GetInstanceFederationMode() (v string) { st.mutex.RLock() @@ -791,15 +2666,15 @@ func (st *ConfigState) SetInstanceFederationMode(v string) { st.reloadToViper() } -// InstanceFederationModeFlag returns the flag name for the 'InstanceFederationMode' field -func InstanceFederationModeFlag() string { return "instance-federation-mode" } - // GetInstanceFederationMode safely fetches the value for global configuration 'InstanceFederationMode' field func GetInstanceFederationMode() string { return global.GetInstanceFederationMode() } // SetInstanceFederationMode safely sets the value for global configuration 'InstanceFederationMode' field func SetInstanceFederationMode(v string) { global.SetInstanceFederationMode(v) } +// InstanceFederationSpamFilterFlag returns the flag name for the 'InstanceFederationSpamFilter' field +func InstanceFederationSpamFilterFlag() string { return "instance-federation-spam-filter" } + // GetInstanceFederationSpamFilter safely fetches the Configuration value for state's 'InstanceFederationSpamFilter' field func (st *ConfigState) GetInstanceFederationSpamFilter() (v bool) { st.mutex.RLock() @@ -816,15 +2691,15 @@ func (st *ConfigState) SetInstanceFederationSpamFilter(v bool) { st.reloadToViper() } -// InstanceFederationSpamFilterFlag returns the flag name for the 'InstanceFederationSpamFilter' field -func InstanceFederationSpamFilterFlag() string { return "instance-federation-spam-filter" } - // GetInstanceFederationSpamFilter safely fetches the value for global configuration 'InstanceFederationSpamFilter' field func GetInstanceFederationSpamFilter() bool { return global.GetInstanceFederationSpamFilter() } // SetInstanceFederationSpamFilter safely sets the value for global configuration 'InstanceFederationSpamFilter' field func SetInstanceFederationSpamFilter(v bool) { global.SetInstanceFederationSpamFilter(v) } +// InstanceExposePeersFlag returns the flag name for the 'InstanceExposePeers' field +func InstanceExposePeersFlag() string { return "instance-expose-peers" } + // GetInstanceExposePeers safely fetches the Configuration value for state's 'InstanceExposePeers' field func (st *ConfigState) GetInstanceExposePeers() (v bool) { st.mutex.RLock() @@ -841,15 +2716,15 @@ func (st *ConfigState) SetInstanceExposePeers(v bool) { st.reloadToViper() } -// InstanceExposePeersFlag returns the flag name for the 'InstanceExposePeers' field -func InstanceExposePeersFlag() string { return "instance-expose-peers" } - // GetInstanceExposePeers safely fetches the value for global configuration 'InstanceExposePeers' field func GetInstanceExposePeers() bool { return global.GetInstanceExposePeers() } // SetInstanceExposePeers safely sets the value for global configuration 'InstanceExposePeers' field func SetInstanceExposePeers(v bool) { global.SetInstanceExposePeers(v) } +// InstanceExposeSuspendedFlag returns the flag name for the 'InstanceExposeSuspended' field +func InstanceExposeSuspendedFlag() string { return "instance-expose-suspended" } + // GetInstanceExposeSuspended safely fetches the Configuration value for state's 'InstanceExposeSuspended' field func (st *ConfigState) GetInstanceExposeSuspended() (v bool) { st.mutex.RLock() @@ -866,15 +2741,15 @@ func (st *ConfigState) SetInstanceExposeSuspended(v bool) { st.reloadToViper() } -// InstanceExposeSuspendedFlag returns the flag name for the 'InstanceExposeSuspended' field -func InstanceExposeSuspendedFlag() string { return "instance-expose-suspended" } - // GetInstanceExposeSuspended safely fetches the value for global configuration 'InstanceExposeSuspended' field func GetInstanceExposeSuspended() bool { return global.GetInstanceExposeSuspended() } // SetInstanceExposeSuspended safely sets the value for global configuration 'InstanceExposeSuspended' field func SetInstanceExposeSuspended(v bool) { global.SetInstanceExposeSuspended(v) } +// InstanceExposeSuspendedWebFlag returns the flag name for the 'InstanceExposeSuspendedWeb' field +func InstanceExposeSuspendedWebFlag() string { return "instance-expose-suspended-web" } + // GetInstanceExposeSuspendedWeb safely fetches the Configuration value for state's 'InstanceExposeSuspendedWeb' field func (st *ConfigState) GetInstanceExposeSuspendedWeb() (v bool) { st.mutex.RLock() @@ -891,15 +2766,15 @@ func (st *ConfigState) SetInstanceExposeSuspendedWeb(v bool) { st.reloadToViper() } -// InstanceExposeSuspendedWebFlag returns the flag name for the 'InstanceExposeSuspendedWeb' field -func InstanceExposeSuspendedWebFlag() string { return "instance-expose-suspended-web" } - // GetInstanceExposeSuspendedWeb safely fetches the value for global configuration 'InstanceExposeSuspendedWeb' field func GetInstanceExposeSuspendedWeb() bool { return global.GetInstanceExposeSuspendedWeb() } // SetInstanceExposeSuspendedWeb safely sets the value for global configuration 'InstanceExposeSuspendedWeb' field func SetInstanceExposeSuspendedWeb(v bool) { global.SetInstanceExposeSuspendedWeb(v) } +// InstanceExposePublicTimelineFlag returns the flag name for the 'InstanceExposePublicTimeline' field +func InstanceExposePublicTimelineFlag() string { return "instance-expose-public-timeline" } + // GetInstanceExposePublicTimeline safely fetches the Configuration value for state's 'InstanceExposePublicTimeline' field func (st *ConfigState) GetInstanceExposePublicTimeline() (v bool) { st.mutex.RLock() @@ -916,15 +2791,15 @@ func (st *ConfigState) SetInstanceExposePublicTimeline(v bool) { st.reloadToViper() } -// InstanceExposePublicTimelineFlag returns the flag name for the 'InstanceExposePublicTimeline' field -func InstanceExposePublicTimelineFlag() string { return "instance-expose-public-timeline" } - // GetInstanceExposePublicTimeline safely fetches the value for global configuration 'InstanceExposePublicTimeline' field func GetInstanceExposePublicTimeline() bool { return global.GetInstanceExposePublicTimeline() } // SetInstanceExposePublicTimeline safely sets the value for global configuration 'InstanceExposePublicTimeline' field func SetInstanceExposePublicTimeline(v bool) { global.SetInstanceExposePublicTimeline(v) } +// InstanceDeliverToSharedInboxesFlag returns the flag name for the 'InstanceDeliverToSharedInboxes' field +func InstanceDeliverToSharedInboxesFlag() string { return "instance-deliver-to-shared-inboxes" } + // GetInstanceDeliverToSharedInboxes safely fetches the Configuration value for state's 'InstanceDeliverToSharedInboxes' field func (st *ConfigState) GetInstanceDeliverToSharedInboxes() (v bool) { st.mutex.RLock() @@ -941,15 +2816,15 @@ func (st *ConfigState) SetInstanceDeliverToSharedInboxes(v bool) { st.reloadToViper() } -// InstanceDeliverToSharedInboxesFlag returns the flag name for the 'InstanceDeliverToSharedInboxes' field -func InstanceDeliverToSharedInboxesFlag() string { return "instance-deliver-to-shared-inboxes" } - // GetInstanceDeliverToSharedInboxes safely fetches the value for global configuration 'InstanceDeliverToSharedInboxes' field func GetInstanceDeliverToSharedInboxes() bool { return global.GetInstanceDeliverToSharedInboxes() } // SetInstanceDeliverToSharedInboxes safely sets the value for global configuration 'InstanceDeliverToSharedInboxes' field func SetInstanceDeliverToSharedInboxes(v bool) { global.SetInstanceDeliverToSharedInboxes(v) } +// InstanceInjectMastodonVersionFlag returns the flag name for the 'InstanceInjectMastodonVersion' field +func InstanceInjectMastodonVersionFlag() string { return "instance-inject-mastodon-version" } + // GetInstanceInjectMastodonVersion safely fetches the Configuration value for state's 'InstanceInjectMastodonVersion' field func (st *ConfigState) GetInstanceInjectMastodonVersion() (v bool) { st.mutex.RLock() @@ -966,15 +2841,15 @@ func (st *ConfigState) SetInstanceInjectMastodonVersion(v bool) { st.reloadToViper() } -// InstanceInjectMastodonVersionFlag returns the flag name for the 'InstanceInjectMastodonVersion' field -func InstanceInjectMastodonVersionFlag() string { return "instance-inject-mastodon-version" } - // GetInstanceInjectMastodonVersion safely fetches the value for global configuration 'InstanceInjectMastodonVersion' field func GetInstanceInjectMastodonVersion() bool { return global.GetInstanceInjectMastodonVersion() } // SetInstanceInjectMastodonVersion safely sets the value for global configuration 'InstanceInjectMastodonVersion' field func SetInstanceInjectMastodonVersion(v bool) { global.SetInstanceInjectMastodonVersion(v) } +// InstanceLanguagesFlag returns the flag name for the 'InstanceLanguages' field +func InstanceLanguagesFlag() string { return "instance-languages" } + // GetInstanceLanguages safely fetches the Configuration value for state's 'InstanceLanguages' field func (st *ConfigState) GetInstanceLanguages() (v language.Languages) { st.mutex.RLock() @@ -991,15 +2866,15 @@ func (st *ConfigState) SetInstanceLanguages(v language.Languages) { st.reloadToViper() } -// InstanceLanguagesFlag returns the flag name for the 'InstanceLanguages' field -func InstanceLanguagesFlag() string { return "instance-languages" } - // GetInstanceLanguages safely fetches the value for global configuration 'InstanceLanguages' field func GetInstanceLanguages() language.Languages { return global.GetInstanceLanguages() } // SetInstanceLanguages safely sets the value for global configuration 'InstanceLanguages' field func SetInstanceLanguages(v language.Languages) { global.SetInstanceLanguages(v) } +// InstanceSubscriptionsProcessFromFlag returns the flag name for the 'InstanceSubscriptionsProcessFrom' field +func InstanceSubscriptionsProcessFromFlag() string { return "instance-subscriptions-process-from" } + // GetInstanceSubscriptionsProcessFrom safely fetches the Configuration value for state's 'InstanceSubscriptionsProcessFrom' field func (st *ConfigState) GetInstanceSubscriptionsProcessFrom() (v string) { st.mutex.RLock() @@ -1016,9 +2891,6 @@ func (st *ConfigState) SetInstanceSubscriptionsProcessFrom(v string) { st.reloadToViper() } -// InstanceSubscriptionsProcessFromFlag returns the flag name for the 'InstanceSubscriptionsProcessFrom' field -func InstanceSubscriptionsProcessFromFlag() string { return "instance-subscriptions-process-from" } - // GetInstanceSubscriptionsProcessFrom safely fetches the value for global configuration 'InstanceSubscriptionsProcessFrom' field func GetInstanceSubscriptionsProcessFrom() string { return global.GetInstanceSubscriptionsProcessFrom() @@ -1027,6 +2899,9 @@ func GetInstanceSubscriptionsProcessFrom() string { // SetInstanceSubscriptionsProcessFrom safely sets the value for global configuration 'InstanceSubscriptionsProcessFrom' field func SetInstanceSubscriptionsProcessFrom(v string) { global.SetInstanceSubscriptionsProcessFrom(v) } +// InstanceSubscriptionsProcessEveryFlag returns the flag name for the 'InstanceSubscriptionsProcessEvery' field +func InstanceSubscriptionsProcessEveryFlag() string { return "instance-subscriptions-process-every" } + // GetInstanceSubscriptionsProcessEvery safely fetches the Configuration value for state's 'InstanceSubscriptionsProcessEvery' field func (st *ConfigState) GetInstanceSubscriptionsProcessEvery() (v time.Duration) { st.mutex.RLock() @@ -1043,9 +2918,6 @@ func (st *ConfigState) SetInstanceSubscriptionsProcessEvery(v time.Duration) { st.reloadToViper() } -// InstanceSubscriptionsProcessEveryFlag returns the flag name for the 'InstanceSubscriptionsProcessEvery' field -func InstanceSubscriptionsProcessEveryFlag() string { return "instance-subscriptions-process-every" } - // GetInstanceSubscriptionsProcessEvery safely fetches the value for global configuration 'InstanceSubscriptionsProcessEvery' field func GetInstanceSubscriptionsProcessEvery() time.Duration { return global.GetInstanceSubscriptionsProcessEvery() @@ -1056,6 +2928,9 @@ func SetInstanceSubscriptionsProcessEvery(v time.Duration) { global.SetInstanceSubscriptionsProcessEvery(v) } +// InstanceStatsModeFlag returns the flag name for the 'InstanceStatsMode' field +func InstanceStatsModeFlag() string { return "instance-stats-mode" } + // GetInstanceStatsMode safely fetches the Configuration value for state's 'InstanceStatsMode' field func (st *ConfigState) GetInstanceStatsMode() (v string) { st.mutex.RLock() @@ -1072,15 +2947,15 @@ func (st *ConfigState) SetInstanceStatsMode(v string) { st.reloadToViper() } -// InstanceStatsModeFlag returns the flag name for the 'InstanceStatsMode' field -func InstanceStatsModeFlag() string { return "instance-stats-mode" } - // GetInstanceStatsMode safely fetches the value for global configuration 'InstanceStatsMode' field func GetInstanceStatsMode() string { return global.GetInstanceStatsMode() } // SetInstanceStatsMode safely sets the value for global configuration 'InstanceStatsMode' field func SetInstanceStatsMode(v string) { global.SetInstanceStatsMode(v) } +// InstanceAllowBackdatingStatusesFlag returns the flag name for the 'InstanceAllowBackdatingStatuses' field +func InstanceAllowBackdatingStatusesFlag() string { return "instance-allow-backdating-statuses" } + // GetInstanceAllowBackdatingStatuses safely fetches the Configuration value for state's 'InstanceAllowBackdatingStatuses' field func (st *ConfigState) GetInstanceAllowBackdatingStatuses() (v bool) { st.mutex.RLock() @@ -1097,15 +2972,15 @@ func (st *ConfigState) SetInstanceAllowBackdatingStatuses(v bool) { st.reloadToViper() } -// InstanceAllowBackdatingStatusesFlag returns the flag name for the 'InstanceAllowBackdatingStatuses' field -func InstanceAllowBackdatingStatusesFlag() string { return "instance-allow-backdating-statuses" } - // GetInstanceAllowBackdatingStatuses safely fetches the value for global configuration 'InstanceAllowBackdatingStatuses' field func GetInstanceAllowBackdatingStatuses() bool { return global.GetInstanceAllowBackdatingStatuses() } // SetInstanceAllowBackdatingStatuses safely sets the value for global configuration 'InstanceAllowBackdatingStatuses' field func SetInstanceAllowBackdatingStatuses(v bool) { global.SetInstanceAllowBackdatingStatuses(v) } +// AccountsRegistrationOpenFlag returns the flag name for the 'AccountsRegistrationOpen' field +func AccountsRegistrationOpenFlag() string { return "accounts-registration-open" } + // GetAccountsRegistrationOpen safely fetches the Configuration value for state's 'AccountsRegistrationOpen' field func (st *ConfigState) GetAccountsRegistrationOpen() (v bool) { st.mutex.RLock() @@ -1122,15 +2997,15 @@ func (st *ConfigState) SetAccountsRegistrationOpen(v bool) { st.reloadToViper() } -// AccountsRegistrationOpenFlag returns the flag name for the 'AccountsRegistrationOpen' field -func AccountsRegistrationOpenFlag() string { return "accounts-registration-open" } - // GetAccountsRegistrationOpen safely fetches the value for global configuration 'AccountsRegistrationOpen' field func GetAccountsRegistrationOpen() bool { return global.GetAccountsRegistrationOpen() } // SetAccountsRegistrationOpen safely sets the value for global configuration 'AccountsRegistrationOpen' field func SetAccountsRegistrationOpen(v bool) { global.SetAccountsRegistrationOpen(v) } +// AccountsReasonRequiredFlag returns the flag name for the 'AccountsReasonRequired' field +func AccountsReasonRequiredFlag() string { return "accounts-reason-required" } + // GetAccountsReasonRequired safely fetches the Configuration value for state's 'AccountsReasonRequired' field func (st *ConfigState) GetAccountsReasonRequired() (v bool) { st.mutex.RLock() @@ -1147,15 +3022,15 @@ func (st *ConfigState) SetAccountsReasonRequired(v bool) { st.reloadToViper() } -// AccountsReasonRequiredFlag returns the flag name for the 'AccountsReasonRequired' field -func AccountsReasonRequiredFlag() string { return "accounts-reason-required" } - // GetAccountsReasonRequired safely fetches the value for global configuration 'AccountsReasonRequired' field func GetAccountsReasonRequired() bool { return global.GetAccountsReasonRequired() } // SetAccountsReasonRequired safely sets the value for global configuration 'AccountsReasonRequired' field func SetAccountsReasonRequired(v bool) { global.SetAccountsReasonRequired(v) } +// AccountsRegistrationDailyLimitFlag returns the flag name for the 'AccountsRegistrationDailyLimit' field +func AccountsRegistrationDailyLimitFlag() string { return "accounts-registration-daily-limit" } + // GetAccountsRegistrationDailyLimit safely fetches the Configuration value for state's 'AccountsRegistrationDailyLimit' field func (st *ConfigState) GetAccountsRegistrationDailyLimit() (v int) { st.mutex.RLock() @@ -1172,15 +3047,15 @@ func (st *ConfigState) SetAccountsRegistrationDailyLimit(v int) { st.reloadToViper() } -// AccountsRegistrationDailyLimitFlag returns the flag name for the 'AccountsRegistrationDailyLimit' field -func AccountsRegistrationDailyLimitFlag() string { return "accounts-registration-daily-limit" } - // GetAccountsRegistrationDailyLimit safely fetches the value for global configuration 'AccountsRegistrationDailyLimit' field func GetAccountsRegistrationDailyLimit() int { return global.GetAccountsRegistrationDailyLimit() } // SetAccountsRegistrationDailyLimit safely sets the value for global configuration 'AccountsRegistrationDailyLimit' field func SetAccountsRegistrationDailyLimit(v int) { global.SetAccountsRegistrationDailyLimit(v) } +// AccountsRegistrationBacklogLimitFlag returns the flag name for the 'AccountsRegistrationBacklogLimit' field +func AccountsRegistrationBacklogLimitFlag() string { return "accounts-registration-backlog-limit" } + // GetAccountsRegistrationBacklogLimit safely fetches the Configuration value for state's 'AccountsRegistrationBacklogLimit' field func (st *ConfigState) GetAccountsRegistrationBacklogLimit() (v int) { st.mutex.RLock() @@ -1197,15 +3072,15 @@ func (st *ConfigState) SetAccountsRegistrationBacklogLimit(v int) { st.reloadToViper() } -// AccountsRegistrationBacklogLimitFlag returns the flag name for the 'AccountsRegistrationBacklogLimit' field -func AccountsRegistrationBacklogLimitFlag() string { return "accounts-registration-backlog-limit" } - // GetAccountsRegistrationBacklogLimit safely fetches the value for global configuration 'AccountsRegistrationBacklogLimit' field func GetAccountsRegistrationBacklogLimit() int { return global.GetAccountsRegistrationBacklogLimit() } // SetAccountsRegistrationBacklogLimit safely sets the value for global configuration 'AccountsRegistrationBacklogLimit' field func SetAccountsRegistrationBacklogLimit(v int) { global.SetAccountsRegistrationBacklogLimit(v) } +// AccountsAllowCustomCSSFlag returns the flag name for the 'AccountsAllowCustomCSS' field +func AccountsAllowCustomCSSFlag() string { return "accounts-allow-custom-css" } + // GetAccountsAllowCustomCSS safely fetches the Configuration value for state's 'AccountsAllowCustomCSS' field func (st *ConfigState) GetAccountsAllowCustomCSS() (v bool) { st.mutex.RLock() @@ -1222,15 +3097,15 @@ func (st *ConfigState) SetAccountsAllowCustomCSS(v bool) { st.reloadToViper() } -// AccountsAllowCustomCSSFlag returns the flag name for the 'AccountsAllowCustomCSS' field -func AccountsAllowCustomCSSFlag() string { return "accounts-allow-custom-css" } - // GetAccountsAllowCustomCSS safely fetches the value for global configuration 'AccountsAllowCustomCSS' field func GetAccountsAllowCustomCSS() bool { return global.GetAccountsAllowCustomCSS() } // SetAccountsAllowCustomCSS safely sets the value for global configuration 'AccountsAllowCustomCSS' field func SetAccountsAllowCustomCSS(v bool) { global.SetAccountsAllowCustomCSS(v) } +// AccountsCustomCSSLengthFlag returns the flag name for the 'AccountsCustomCSSLength' field +func AccountsCustomCSSLengthFlag() string { return "accounts-custom-css-length" } + // GetAccountsCustomCSSLength safely fetches the Configuration value for state's 'AccountsCustomCSSLength' field func (st *ConfigState) GetAccountsCustomCSSLength() (v int) { st.mutex.RLock() @@ -1247,15 +3122,15 @@ func (st *ConfigState) SetAccountsCustomCSSLength(v int) { st.reloadToViper() } -// AccountsCustomCSSLengthFlag returns the flag name for the 'AccountsCustomCSSLength' field -func AccountsCustomCSSLengthFlag() string { return "accounts-custom-css-length" } - // GetAccountsCustomCSSLength safely fetches the value for global configuration 'AccountsCustomCSSLength' field func GetAccountsCustomCSSLength() int { return global.GetAccountsCustomCSSLength() } // SetAccountsCustomCSSLength safely sets the value for global configuration 'AccountsCustomCSSLength' field func SetAccountsCustomCSSLength(v int) { global.SetAccountsCustomCSSLength(v) } +// MediaDescriptionMinCharsFlag returns the flag name for the 'MediaDescriptionMinChars' field +func MediaDescriptionMinCharsFlag() string { return "media-description-min-chars" } + // GetMediaDescriptionMinChars safely fetches the Configuration value for state's 'MediaDescriptionMinChars' field func (st *ConfigState) GetMediaDescriptionMinChars() (v int) { st.mutex.RLock() @@ -1272,15 +3147,15 @@ func (st *ConfigState) SetMediaDescriptionMinChars(v int) { st.reloadToViper() } -// MediaDescriptionMinCharsFlag returns the flag name for the 'MediaDescriptionMinChars' field -func MediaDescriptionMinCharsFlag() string { return "media-description-min-chars" } - // GetMediaDescriptionMinChars safely fetches the value for global configuration 'MediaDescriptionMinChars' field func GetMediaDescriptionMinChars() int { return global.GetMediaDescriptionMinChars() } // SetMediaDescriptionMinChars safely sets the value for global configuration 'MediaDescriptionMinChars' field func SetMediaDescriptionMinChars(v int) { global.SetMediaDescriptionMinChars(v) } +// MediaDescriptionMaxCharsFlag returns the flag name for the 'MediaDescriptionMaxChars' field +func MediaDescriptionMaxCharsFlag() string { return "media-description-max-chars" } + // GetMediaDescriptionMaxChars safely fetches the Configuration value for state's 'MediaDescriptionMaxChars' field func (st *ConfigState) GetMediaDescriptionMaxChars() (v int) { st.mutex.RLock() @@ -1297,15 +3172,15 @@ func (st *ConfigState) SetMediaDescriptionMaxChars(v int) { st.reloadToViper() } -// MediaDescriptionMaxCharsFlag returns the flag name for the 'MediaDescriptionMaxChars' field -func MediaDescriptionMaxCharsFlag() string { return "media-description-max-chars" } - // GetMediaDescriptionMaxChars safely fetches the value for global configuration 'MediaDescriptionMaxChars' field func GetMediaDescriptionMaxChars() int { return global.GetMediaDescriptionMaxChars() } // SetMediaDescriptionMaxChars safely sets the value for global configuration 'MediaDescriptionMaxChars' field func SetMediaDescriptionMaxChars(v int) { global.SetMediaDescriptionMaxChars(v) } +// MediaRemoteCacheDaysFlag returns the flag name for the 'MediaRemoteCacheDays' field +func MediaRemoteCacheDaysFlag() string { return "media-remote-cache-days" } + // GetMediaRemoteCacheDays safely fetches the Configuration value for state's 'MediaRemoteCacheDays' field func (st *ConfigState) GetMediaRemoteCacheDays() (v int) { st.mutex.RLock() @@ -1322,15 +3197,15 @@ func (st *ConfigState) SetMediaRemoteCacheDays(v int) { st.reloadToViper() } -// MediaRemoteCacheDaysFlag returns the flag name for the 'MediaRemoteCacheDays' field -func MediaRemoteCacheDaysFlag() string { return "media-remote-cache-days" } - // GetMediaRemoteCacheDays safely fetches the value for global configuration 'MediaRemoteCacheDays' field func GetMediaRemoteCacheDays() int { return global.GetMediaRemoteCacheDays() } // SetMediaRemoteCacheDays safely sets the value for global configuration 'MediaRemoteCacheDays' field func SetMediaRemoteCacheDays(v int) { global.SetMediaRemoteCacheDays(v) } +// MediaEmojiLocalMaxSizeFlag returns the flag name for the 'MediaEmojiLocalMaxSize' field +func MediaEmojiLocalMaxSizeFlag() string { return "media-emoji-local-max-size" } + // GetMediaEmojiLocalMaxSize safely fetches the Configuration value for state's 'MediaEmojiLocalMaxSize' field func (st *ConfigState) GetMediaEmojiLocalMaxSize() (v bytesize.Size) { st.mutex.RLock() @@ -1347,15 +3222,15 @@ func (st *ConfigState) SetMediaEmojiLocalMaxSize(v bytesize.Size) { st.reloadToViper() } -// MediaEmojiLocalMaxSizeFlag returns the flag name for the 'MediaEmojiLocalMaxSize' field -func MediaEmojiLocalMaxSizeFlag() string { return "media-emoji-local-max-size" } - // GetMediaEmojiLocalMaxSize safely fetches the value for global configuration 'MediaEmojiLocalMaxSize' field func GetMediaEmojiLocalMaxSize() bytesize.Size { return global.GetMediaEmojiLocalMaxSize() } // SetMediaEmojiLocalMaxSize safely sets the value for global configuration 'MediaEmojiLocalMaxSize' field func SetMediaEmojiLocalMaxSize(v bytesize.Size) { global.SetMediaEmojiLocalMaxSize(v) } +// MediaEmojiRemoteMaxSizeFlag returns the flag name for the 'MediaEmojiRemoteMaxSize' field +func MediaEmojiRemoteMaxSizeFlag() string { return "media-emoji-remote-max-size" } + // GetMediaEmojiRemoteMaxSize safely fetches the Configuration value for state's 'MediaEmojiRemoteMaxSize' field func (st *ConfigState) GetMediaEmojiRemoteMaxSize() (v bytesize.Size) { st.mutex.RLock() @@ -1372,15 +3247,15 @@ func (st *ConfigState) SetMediaEmojiRemoteMaxSize(v bytesize.Size) { st.reloadToViper() } -// MediaEmojiRemoteMaxSizeFlag returns the flag name for the 'MediaEmojiRemoteMaxSize' field -func MediaEmojiRemoteMaxSizeFlag() string { return "media-emoji-remote-max-size" } - // GetMediaEmojiRemoteMaxSize safely fetches the value for global configuration 'MediaEmojiRemoteMaxSize' field func GetMediaEmojiRemoteMaxSize() bytesize.Size { return global.GetMediaEmojiRemoteMaxSize() } // SetMediaEmojiRemoteMaxSize safely sets the value for global configuration 'MediaEmojiRemoteMaxSize' field func SetMediaEmojiRemoteMaxSize(v bytesize.Size) { global.SetMediaEmojiRemoteMaxSize(v) } +// MediaImageSizeHintFlag returns the flag name for the 'MediaImageSizeHint' field +func MediaImageSizeHintFlag() string { return "media-image-size-hint" } + // GetMediaImageSizeHint safely fetches the Configuration value for state's 'MediaImageSizeHint' field func (st *ConfigState) GetMediaImageSizeHint() (v bytesize.Size) { st.mutex.RLock() @@ -1397,15 +3272,15 @@ func (st *ConfigState) SetMediaImageSizeHint(v bytesize.Size) { st.reloadToViper() } -// MediaImageSizeHintFlag returns the flag name for the 'MediaImageSizeHint' field -func MediaImageSizeHintFlag() string { return "media-image-size-hint" } - // GetMediaImageSizeHint safely fetches the value for global configuration 'MediaImageSizeHint' field func GetMediaImageSizeHint() bytesize.Size { return global.GetMediaImageSizeHint() } // SetMediaImageSizeHint safely sets the value for global configuration 'MediaImageSizeHint' field func SetMediaImageSizeHint(v bytesize.Size) { global.SetMediaImageSizeHint(v) } +// MediaVideoSizeHintFlag returns the flag name for the 'MediaVideoSizeHint' field +func MediaVideoSizeHintFlag() string { return "media-video-size-hint" } + // GetMediaVideoSizeHint safely fetches the Configuration value for state's 'MediaVideoSizeHint' field func (st *ConfigState) GetMediaVideoSizeHint() (v bytesize.Size) { st.mutex.RLock() @@ -1422,15 +3297,15 @@ func (st *ConfigState) SetMediaVideoSizeHint(v bytesize.Size) { st.reloadToViper() } -// MediaVideoSizeHintFlag returns the flag name for the 'MediaVideoSizeHint' field -func MediaVideoSizeHintFlag() string { return "media-video-size-hint" } - // GetMediaVideoSizeHint safely fetches the value for global configuration 'MediaVideoSizeHint' field func GetMediaVideoSizeHint() bytesize.Size { return global.GetMediaVideoSizeHint() } // SetMediaVideoSizeHint safely sets the value for global configuration 'MediaVideoSizeHint' field func SetMediaVideoSizeHint(v bytesize.Size) { global.SetMediaVideoSizeHint(v) } +// MediaLocalMaxSizeFlag returns the flag name for the 'MediaLocalMaxSize' field +func MediaLocalMaxSizeFlag() string { return "media-local-max-size" } + // GetMediaLocalMaxSize safely fetches the Configuration value for state's 'MediaLocalMaxSize' field func (st *ConfigState) GetMediaLocalMaxSize() (v bytesize.Size) { st.mutex.RLock() @@ -1447,15 +3322,15 @@ func (st *ConfigState) SetMediaLocalMaxSize(v bytesize.Size) { st.reloadToViper() } -// MediaLocalMaxSizeFlag returns the flag name for the 'MediaLocalMaxSize' field -func MediaLocalMaxSizeFlag() string { return "media-local-max-size" } - // GetMediaLocalMaxSize safely fetches the value for global configuration 'MediaLocalMaxSize' field func GetMediaLocalMaxSize() bytesize.Size { return global.GetMediaLocalMaxSize() } // SetMediaLocalMaxSize safely sets the value for global configuration 'MediaLocalMaxSize' field func SetMediaLocalMaxSize(v bytesize.Size) { global.SetMediaLocalMaxSize(v) } +// MediaRemoteMaxSizeFlag returns the flag name for the 'MediaRemoteMaxSize' field +func MediaRemoteMaxSizeFlag() string { return "media-remote-max-size" } + // GetMediaRemoteMaxSize safely fetches the Configuration value for state's 'MediaRemoteMaxSize' field func (st *ConfigState) GetMediaRemoteMaxSize() (v bytesize.Size) { st.mutex.RLock() @@ -1472,15 +3347,15 @@ func (st *ConfigState) SetMediaRemoteMaxSize(v bytesize.Size) { st.reloadToViper() } -// MediaRemoteMaxSizeFlag returns the flag name for the 'MediaRemoteMaxSize' field -func MediaRemoteMaxSizeFlag() string { return "media-remote-max-size" } - // GetMediaRemoteMaxSize safely fetches the value for global configuration 'MediaRemoteMaxSize' field func GetMediaRemoteMaxSize() bytesize.Size { return global.GetMediaRemoteMaxSize() } // SetMediaRemoteMaxSize safely sets the value for global configuration 'MediaRemoteMaxSize' field func SetMediaRemoteMaxSize(v bytesize.Size) { global.SetMediaRemoteMaxSize(v) } +// MediaCleanupFromFlag returns the flag name for the 'MediaCleanupFrom' field +func MediaCleanupFromFlag() string { return "media-cleanup-from" } + // GetMediaCleanupFrom safely fetches the Configuration value for state's 'MediaCleanupFrom' field func (st *ConfigState) GetMediaCleanupFrom() (v string) { st.mutex.RLock() @@ -1497,15 +3372,15 @@ func (st *ConfigState) SetMediaCleanupFrom(v string) { st.reloadToViper() } -// MediaCleanupFromFlag returns the flag name for the 'MediaCleanupFrom' field -func MediaCleanupFromFlag() string { return "media-cleanup-from" } - // GetMediaCleanupFrom safely fetches the value for global configuration 'MediaCleanupFrom' field func GetMediaCleanupFrom() string { return global.GetMediaCleanupFrom() } // SetMediaCleanupFrom safely sets the value for global configuration 'MediaCleanupFrom' field func SetMediaCleanupFrom(v string) { global.SetMediaCleanupFrom(v) } +// MediaCleanupEveryFlag returns the flag name for the 'MediaCleanupEvery' field +func MediaCleanupEveryFlag() string { return "media-cleanup-every" } + // GetMediaCleanupEvery safely fetches the Configuration value for state's 'MediaCleanupEvery' field func (st *ConfigState) GetMediaCleanupEvery() (v time.Duration) { st.mutex.RLock() @@ -1522,15 +3397,15 @@ func (st *ConfigState) SetMediaCleanupEvery(v time.Duration) { st.reloadToViper() } -// MediaCleanupEveryFlag returns the flag name for the 'MediaCleanupEvery' field -func MediaCleanupEveryFlag() string { return "media-cleanup-every" } - // GetMediaCleanupEvery safely fetches the value for global configuration 'MediaCleanupEvery' field func GetMediaCleanupEvery() time.Duration { return global.GetMediaCleanupEvery() } // SetMediaCleanupEvery safely sets the value for global configuration 'MediaCleanupEvery' field func SetMediaCleanupEvery(v time.Duration) { global.SetMediaCleanupEvery(v) } +// MediaFfmpegPoolSizeFlag returns the flag name for the 'MediaFfmpegPoolSize' field +func MediaFfmpegPoolSizeFlag() string { return "media-ffmpeg-pool-size" } + // GetMediaFfmpegPoolSize safely fetches the Configuration value for state's 'MediaFfmpegPoolSize' field func (st *ConfigState) GetMediaFfmpegPoolSize() (v int) { st.mutex.RLock() @@ -1547,15 +3422,15 @@ func (st *ConfigState) SetMediaFfmpegPoolSize(v int) { st.reloadToViper() } -// MediaFfmpegPoolSizeFlag returns the flag name for the 'MediaFfmpegPoolSize' field -func MediaFfmpegPoolSizeFlag() string { return "media-ffmpeg-pool-size" } - // GetMediaFfmpegPoolSize safely fetches the value for global configuration 'MediaFfmpegPoolSize' field func GetMediaFfmpegPoolSize() int { return global.GetMediaFfmpegPoolSize() } // SetMediaFfmpegPoolSize safely sets the value for global configuration 'MediaFfmpegPoolSize' field func SetMediaFfmpegPoolSize(v int) { global.SetMediaFfmpegPoolSize(v) } +// StorageBackendFlag returns the flag name for the 'StorageBackend' field +func StorageBackendFlag() string { return "storage-backend" } + // GetStorageBackend safely fetches the Configuration value for state's 'StorageBackend' field func (st *ConfigState) GetStorageBackend() (v string) { st.mutex.RLock() @@ -1572,15 +3447,15 @@ func (st *ConfigState) SetStorageBackend(v string) { st.reloadToViper() } -// StorageBackendFlag returns the flag name for the 'StorageBackend' field -func StorageBackendFlag() string { return "storage-backend" } - // GetStorageBackend safely fetches the value for global configuration 'StorageBackend' field func GetStorageBackend() string { return global.GetStorageBackend() } // SetStorageBackend safely sets the value for global configuration 'StorageBackend' field func SetStorageBackend(v string) { global.SetStorageBackend(v) } +// StorageLocalBasePathFlag returns the flag name for the 'StorageLocalBasePath' field +func StorageLocalBasePathFlag() string { return "storage-local-base-path" } + // GetStorageLocalBasePath safely fetches the Configuration value for state's 'StorageLocalBasePath' field func (st *ConfigState) GetStorageLocalBasePath() (v string) { st.mutex.RLock() @@ -1597,15 +3472,15 @@ func (st *ConfigState) SetStorageLocalBasePath(v string) { st.reloadToViper() } -// StorageLocalBasePathFlag returns the flag name for the 'StorageLocalBasePath' field -func StorageLocalBasePathFlag() string { return "storage-local-base-path" } - // GetStorageLocalBasePath safely fetches the value for global configuration 'StorageLocalBasePath' field func GetStorageLocalBasePath() string { return global.GetStorageLocalBasePath() } // SetStorageLocalBasePath safely sets the value for global configuration 'StorageLocalBasePath' field func SetStorageLocalBasePath(v string) { global.SetStorageLocalBasePath(v) } +// StorageS3EndpointFlag returns the flag name for the 'StorageS3Endpoint' field +func StorageS3EndpointFlag() string { return "storage-s3-endpoint" } + // GetStorageS3Endpoint safely fetches the Configuration value for state's 'StorageS3Endpoint' field func (st *ConfigState) GetStorageS3Endpoint() (v string) { st.mutex.RLock() @@ -1622,15 +3497,15 @@ func (st *ConfigState) SetStorageS3Endpoint(v string) { st.reloadToViper() } -// StorageS3EndpointFlag returns the flag name for the 'StorageS3Endpoint' field -func StorageS3EndpointFlag() string { return "storage-s3-endpoint" } - // GetStorageS3Endpoint safely fetches the value for global configuration 'StorageS3Endpoint' field func GetStorageS3Endpoint() string { return global.GetStorageS3Endpoint() } // SetStorageS3Endpoint safely sets the value for global configuration 'StorageS3Endpoint' field func SetStorageS3Endpoint(v string) { global.SetStorageS3Endpoint(v) } +// StorageS3AccessKeyFlag returns the flag name for the 'StorageS3AccessKey' field +func StorageS3AccessKeyFlag() string { return "storage-s3-access-key" } + // GetStorageS3AccessKey safely fetches the Configuration value for state's 'StorageS3AccessKey' field func (st *ConfigState) GetStorageS3AccessKey() (v string) { st.mutex.RLock() @@ -1647,15 +3522,15 @@ func (st *ConfigState) SetStorageS3AccessKey(v string) { st.reloadToViper() } -// StorageS3AccessKeyFlag returns the flag name for the 'StorageS3AccessKey' field -func StorageS3AccessKeyFlag() string { return "storage-s3-access-key" } - // GetStorageS3AccessKey safely fetches the value for global configuration 'StorageS3AccessKey' field func GetStorageS3AccessKey() string { return global.GetStorageS3AccessKey() } // SetStorageS3AccessKey safely sets the value for global configuration 'StorageS3AccessKey' field func SetStorageS3AccessKey(v string) { global.SetStorageS3AccessKey(v) } +// StorageS3SecretKeyFlag returns the flag name for the 'StorageS3SecretKey' field +func StorageS3SecretKeyFlag() string { return "storage-s3-secret-key" } + // GetStorageS3SecretKey safely fetches the Configuration value for state's 'StorageS3SecretKey' field func (st *ConfigState) GetStorageS3SecretKey() (v string) { st.mutex.RLock() @@ -1672,15 +3547,15 @@ func (st *ConfigState) SetStorageS3SecretKey(v string) { st.reloadToViper() } -// StorageS3SecretKeyFlag returns the flag name for the 'StorageS3SecretKey' field -func StorageS3SecretKeyFlag() string { return "storage-s3-secret-key" } - // GetStorageS3SecretKey safely fetches the value for global configuration 'StorageS3SecretKey' field func GetStorageS3SecretKey() string { return global.GetStorageS3SecretKey() } // SetStorageS3SecretKey safely sets the value for global configuration 'StorageS3SecretKey' field func SetStorageS3SecretKey(v string) { global.SetStorageS3SecretKey(v) } +// StorageS3UseSSLFlag returns the flag name for the 'StorageS3UseSSL' field +func StorageS3UseSSLFlag() string { return "storage-s3-use-ssl" } + // GetStorageS3UseSSL safely fetches the Configuration value for state's 'StorageS3UseSSL' field func (st *ConfigState) GetStorageS3UseSSL() (v bool) { st.mutex.RLock() @@ -1697,15 +3572,15 @@ func (st *ConfigState) SetStorageS3UseSSL(v bool) { st.reloadToViper() } -// StorageS3UseSSLFlag returns the flag name for the 'StorageS3UseSSL' field -func StorageS3UseSSLFlag() string { return "storage-s3-use-ssl" } - // GetStorageS3UseSSL safely fetches the value for global configuration 'StorageS3UseSSL' field func GetStorageS3UseSSL() bool { return global.GetStorageS3UseSSL() } // SetStorageS3UseSSL safely sets the value for global configuration 'StorageS3UseSSL' field func SetStorageS3UseSSL(v bool) { global.SetStorageS3UseSSL(v) } +// StorageS3BucketNameFlag returns the flag name for the 'StorageS3BucketName' field +func StorageS3BucketNameFlag() string { return "storage-s3-bucket" } + // GetStorageS3BucketName safely fetches the Configuration value for state's 'StorageS3BucketName' field func (st *ConfigState) GetStorageS3BucketName() (v string) { st.mutex.RLock() @@ -1722,15 +3597,15 @@ func (st *ConfigState) SetStorageS3BucketName(v string) { st.reloadToViper() } -// StorageS3BucketNameFlag returns the flag name for the 'StorageS3BucketName' field -func StorageS3BucketNameFlag() string { return "storage-s3-bucket" } - // GetStorageS3BucketName safely fetches the value for global configuration 'StorageS3BucketName' field func GetStorageS3BucketName() string { return global.GetStorageS3BucketName() } // SetStorageS3BucketName safely sets the value for global configuration 'StorageS3BucketName' field func SetStorageS3BucketName(v string) { global.SetStorageS3BucketName(v) } +// StorageS3ProxyFlag returns the flag name for the 'StorageS3Proxy' field +func StorageS3ProxyFlag() string { return "storage-s3-proxy" } + // GetStorageS3Proxy safely fetches the Configuration value for state's 'StorageS3Proxy' field func (st *ConfigState) GetStorageS3Proxy() (v bool) { st.mutex.RLock() @@ -1747,15 +3622,15 @@ func (st *ConfigState) SetStorageS3Proxy(v bool) { st.reloadToViper() } -// StorageS3ProxyFlag returns the flag name for the 'StorageS3Proxy' field -func StorageS3ProxyFlag() string { return "storage-s3-proxy" } - // GetStorageS3Proxy safely fetches the value for global configuration 'StorageS3Proxy' field func GetStorageS3Proxy() bool { return global.GetStorageS3Proxy() } // SetStorageS3Proxy safely sets the value for global configuration 'StorageS3Proxy' field func SetStorageS3Proxy(v bool) { global.SetStorageS3Proxy(v) } +// StorageS3RedirectURLFlag returns the flag name for the 'StorageS3RedirectURL' field +func StorageS3RedirectURLFlag() string { return "storage-s3-redirect-url" } + // GetStorageS3RedirectURL safely fetches the Configuration value for state's 'StorageS3RedirectURL' field func (st *ConfigState) GetStorageS3RedirectURL() (v string) { st.mutex.RLock() @@ -1772,15 +3647,15 @@ func (st *ConfigState) SetStorageS3RedirectURL(v string) { st.reloadToViper() } -// StorageS3RedirectURLFlag returns the flag name for the 'StorageS3RedirectURL' field -func StorageS3RedirectURLFlag() string { return "storage-s3-redirect-url" } - // GetStorageS3RedirectURL safely fetches the value for global configuration 'StorageS3RedirectURL' field func GetStorageS3RedirectURL() string { return global.GetStorageS3RedirectURL() } // SetStorageS3RedirectURL safely sets the value for global configuration 'StorageS3RedirectURL' field func SetStorageS3RedirectURL(v string) { global.SetStorageS3RedirectURL(v) } +// StorageS3BucketLookupFlag returns the flag name for the 'StorageS3BucketLookup' field +func StorageS3BucketLookupFlag() string { return "storage-s3-bucket-lookup" } + // GetStorageS3BucketLookup safely fetches the Configuration value for state's 'StorageS3BucketLookup' field func (st *ConfigState) GetStorageS3BucketLookup() (v string) { st.mutex.RLock() @@ -1797,15 +3672,15 @@ func (st *ConfigState) SetStorageS3BucketLookup(v string) { st.reloadToViper() } -// StorageS3BucketLookupFlag returns the flag name for the 'StorageS3BucketLookup' field -func StorageS3BucketLookupFlag() string { return "storage-s3-bucket-lookup" } - // GetStorageS3BucketLookup safely fetches the value for global configuration 'StorageS3BucketLookup' field func GetStorageS3BucketLookup() string { return global.GetStorageS3BucketLookup() } // SetStorageS3BucketLookup safely sets the value for global configuration 'StorageS3BucketLookup' field func SetStorageS3BucketLookup(v string) { global.SetStorageS3BucketLookup(v) } +// StatusesMaxCharsFlag returns the flag name for the 'StatusesMaxChars' field +func StatusesMaxCharsFlag() string { return "statuses-max-chars" } + // GetStatusesMaxChars safely fetches the Configuration value for state's 'StatusesMaxChars' field func (st *ConfigState) GetStatusesMaxChars() (v int) { st.mutex.RLock() @@ -1822,15 +3697,15 @@ func (st *ConfigState) SetStatusesMaxChars(v int) { st.reloadToViper() } -// StatusesMaxCharsFlag returns the flag name for the 'StatusesMaxChars' field -func StatusesMaxCharsFlag() string { return "statuses-max-chars" } - // GetStatusesMaxChars safely fetches the value for global configuration 'StatusesMaxChars' field func GetStatusesMaxChars() int { return global.GetStatusesMaxChars() } // SetStatusesMaxChars safely sets the value for global configuration 'StatusesMaxChars' field func SetStatusesMaxChars(v int) { global.SetStatusesMaxChars(v) } +// StatusesPollMaxOptionsFlag returns the flag name for the 'StatusesPollMaxOptions' field +func StatusesPollMaxOptionsFlag() string { return "statuses-poll-max-options" } + // GetStatusesPollMaxOptions safely fetches the Configuration value for state's 'StatusesPollMaxOptions' field func (st *ConfigState) GetStatusesPollMaxOptions() (v int) { st.mutex.RLock() @@ -1847,15 +3722,15 @@ func (st *ConfigState) SetStatusesPollMaxOptions(v int) { st.reloadToViper() } -// StatusesPollMaxOptionsFlag returns the flag name for the 'StatusesPollMaxOptions' field -func StatusesPollMaxOptionsFlag() string { return "statuses-poll-max-options" } - // GetStatusesPollMaxOptions safely fetches the value for global configuration 'StatusesPollMaxOptions' field func GetStatusesPollMaxOptions() int { return global.GetStatusesPollMaxOptions() } // SetStatusesPollMaxOptions safely sets the value for global configuration 'StatusesPollMaxOptions' field func SetStatusesPollMaxOptions(v int) { global.SetStatusesPollMaxOptions(v) } +// StatusesPollOptionMaxCharsFlag returns the flag name for the 'StatusesPollOptionMaxChars' field +func StatusesPollOptionMaxCharsFlag() string { return "statuses-poll-option-max-chars" } + // GetStatusesPollOptionMaxChars safely fetches the Configuration value for state's 'StatusesPollOptionMaxChars' field func (st *ConfigState) GetStatusesPollOptionMaxChars() (v int) { st.mutex.RLock() @@ -1872,15 +3747,15 @@ func (st *ConfigState) SetStatusesPollOptionMaxChars(v int) { st.reloadToViper() } -// StatusesPollOptionMaxCharsFlag returns the flag name for the 'StatusesPollOptionMaxChars' field -func StatusesPollOptionMaxCharsFlag() string { return "statuses-poll-option-max-chars" } - // GetStatusesPollOptionMaxChars safely fetches the value for global configuration 'StatusesPollOptionMaxChars' field func GetStatusesPollOptionMaxChars() int { return global.GetStatusesPollOptionMaxChars() } // SetStatusesPollOptionMaxChars safely sets the value for global configuration 'StatusesPollOptionMaxChars' field func SetStatusesPollOptionMaxChars(v int) { global.SetStatusesPollOptionMaxChars(v) } +// StatusesMediaMaxFilesFlag returns the flag name for the 'StatusesMediaMaxFiles' field +func StatusesMediaMaxFilesFlag() string { return "statuses-media-max-files" } + // GetStatusesMediaMaxFiles safely fetches the Configuration value for state's 'StatusesMediaMaxFiles' field func (st *ConfigState) GetStatusesMediaMaxFiles() (v int) { st.mutex.RLock() @@ -1897,15 +3772,15 @@ func (st *ConfigState) SetStatusesMediaMaxFiles(v int) { st.reloadToViper() } -// StatusesMediaMaxFilesFlag returns the flag name for the 'StatusesMediaMaxFiles' field -func StatusesMediaMaxFilesFlag() string { return "statuses-media-max-files" } - // GetStatusesMediaMaxFiles safely fetches the value for global configuration 'StatusesMediaMaxFiles' field func GetStatusesMediaMaxFiles() int { return global.GetStatusesMediaMaxFiles() } // SetStatusesMediaMaxFiles safely sets the value for global configuration 'StatusesMediaMaxFiles' field func SetStatusesMediaMaxFiles(v int) { global.SetStatusesMediaMaxFiles(v) } +// LetsEncryptEnabledFlag returns the flag name for the 'LetsEncryptEnabled' field +func LetsEncryptEnabledFlag() string { return "letsencrypt-enabled" } + // GetLetsEncryptEnabled safely fetches the Configuration value for state's 'LetsEncryptEnabled' field func (st *ConfigState) GetLetsEncryptEnabled() (v bool) { st.mutex.RLock() @@ -1922,15 +3797,15 @@ func (st *ConfigState) SetLetsEncryptEnabled(v bool) { st.reloadToViper() } -// LetsEncryptEnabledFlag returns the flag name for the 'LetsEncryptEnabled' field -func LetsEncryptEnabledFlag() string { return "letsencrypt-enabled" } - // GetLetsEncryptEnabled safely fetches the value for global configuration 'LetsEncryptEnabled' field func GetLetsEncryptEnabled() bool { return global.GetLetsEncryptEnabled() } // SetLetsEncryptEnabled safely sets the value for global configuration 'LetsEncryptEnabled' field func SetLetsEncryptEnabled(v bool) { global.SetLetsEncryptEnabled(v) } +// LetsEncryptPortFlag returns the flag name for the 'LetsEncryptPort' field +func LetsEncryptPortFlag() string { return "letsencrypt-port" } + // GetLetsEncryptPort safely fetches the Configuration value for state's 'LetsEncryptPort' field func (st *ConfigState) GetLetsEncryptPort() (v int) { st.mutex.RLock() @@ -1947,15 +3822,15 @@ func (st *ConfigState) SetLetsEncryptPort(v int) { st.reloadToViper() } -// LetsEncryptPortFlag returns the flag name for the 'LetsEncryptPort' field -func LetsEncryptPortFlag() string { return "letsencrypt-port" } - // GetLetsEncryptPort safely fetches the value for global configuration 'LetsEncryptPort' field func GetLetsEncryptPort() int { return global.GetLetsEncryptPort() } // SetLetsEncryptPort safely sets the value for global configuration 'LetsEncryptPort' field func SetLetsEncryptPort(v int) { global.SetLetsEncryptPort(v) } +// LetsEncryptCertDirFlag returns the flag name for the 'LetsEncryptCertDir' field +func LetsEncryptCertDirFlag() string { return "letsencrypt-cert-dir" } + // GetLetsEncryptCertDir safely fetches the Configuration value for state's 'LetsEncryptCertDir' field func (st *ConfigState) GetLetsEncryptCertDir() (v string) { st.mutex.RLock() @@ -1972,15 +3847,15 @@ func (st *ConfigState) SetLetsEncryptCertDir(v string) { st.reloadToViper() } -// LetsEncryptCertDirFlag returns the flag name for the 'LetsEncryptCertDir' field -func LetsEncryptCertDirFlag() string { return "letsencrypt-cert-dir" } - // GetLetsEncryptCertDir safely fetches the value for global configuration 'LetsEncryptCertDir' field func GetLetsEncryptCertDir() string { return global.GetLetsEncryptCertDir() } // SetLetsEncryptCertDir safely sets the value for global configuration 'LetsEncryptCertDir' field func SetLetsEncryptCertDir(v string) { global.SetLetsEncryptCertDir(v) } +// LetsEncryptEmailAddressFlag returns the flag name for the 'LetsEncryptEmailAddress' field +func LetsEncryptEmailAddressFlag() string { return "letsencrypt-email-address" } + // GetLetsEncryptEmailAddress safely fetches the Configuration value for state's 'LetsEncryptEmailAddress' field func (st *ConfigState) GetLetsEncryptEmailAddress() (v string) { st.mutex.RLock() @@ -1997,15 +3872,15 @@ func (st *ConfigState) SetLetsEncryptEmailAddress(v string) { st.reloadToViper() } -// LetsEncryptEmailAddressFlag returns the flag name for the 'LetsEncryptEmailAddress' field -func LetsEncryptEmailAddressFlag() string { return "letsencrypt-email-address" } - // GetLetsEncryptEmailAddress safely fetches the value for global configuration 'LetsEncryptEmailAddress' field func GetLetsEncryptEmailAddress() string { return global.GetLetsEncryptEmailAddress() } // SetLetsEncryptEmailAddress safely sets the value for global configuration 'LetsEncryptEmailAddress' field func SetLetsEncryptEmailAddress(v string) { global.SetLetsEncryptEmailAddress(v) } +// TLSCertificateChainFlag returns the flag name for the 'TLSCertificateChain' field +func TLSCertificateChainFlag() string { return "tls-certificate-chain" } + // GetTLSCertificateChain safely fetches the Configuration value for state's 'TLSCertificateChain' field func (st *ConfigState) GetTLSCertificateChain() (v string) { st.mutex.RLock() @@ -2022,15 +3897,15 @@ func (st *ConfigState) SetTLSCertificateChain(v string) { st.reloadToViper() } -// TLSCertificateChainFlag returns the flag name for the 'TLSCertificateChain' field -func TLSCertificateChainFlag() string { return "tls-certificate-chain" } - // GetTLSCertificateChain safely fetches the value for global configuration 'TLSCertificateChain' field func GetTLSCertificateChain() string { return global.GetTLSCertificateChain() } // SetTLSCertificateChain safely sets the value for global configuration 'TLSCertificateChain' field func SetTLSCertificateChain(v string) { global.SetTLSCertificateChain(v) } +// TLSCertificateKeyFlag returns the flag name for the 'TLSCertificateKey' field +func TLSCertificateKeyFlag() string { return "tls-certificate-key" } + // GetTLSCertificateKey safely fetches the Configuration value for state's 'TLSCertificateKey' field func (st *ConfigState) GetTLSCertificateKey() (v string) { st.mutex.RLock() @@ -2047,15 +3922,15 @@ func (st *ConfigState) SetTLSCertificateKey(v string) { st.reloadToViper() } -// TLSCertificateKeyFlag returns the flag name for the 'TLSCertificateKey' field -func TLSCertificateKeyFlag() string { return "tls-certificate-key" } - // GetTLSCertificateKey safely fetches the value for global configuration 'TLSCertificateKey' field func GetTLSCertificateKey() string { return global.GetTLSCertificateKey() } // SetTLSCertificateKey safely sets the value for global configuration 'TLSCertificateKey' field func SetTLSCertificateKey(v string) { global.SetTLSCertificateKey(v) } +// OIDCEnabledFlag returns the flag name for the 'OIDCEnabled' field +func OIDCEnabledFlag() string { return "oidc-enabled" } + // GetOIDCEnabled safely fetches the Configuration value for state's 'OIDCEnabled' field func (st *ConfigState) GetOIDCEnabled() (v bool) { st.mutex.RLock() @@ -2072,15 +3947,15 @@ func (st *ConfigState) SetOIDCEnabled(v bool) { st.reloadToViper() } -// OIDCEnabledFlag returns the flag name for the 'OIDCEnabled' field -func OIDCEnabledFlag() string { return "oidc-enabled" } - // GetOIDCEnabled safely fetches the value for global configuration 'OIDCEnabled' field func GetOIDCEnabled() bool { return global.GetOIDCEnabled() } // SetOIDCEnabled safely sets the value for global configuration 'OIDCEnabled' field func SetOIDCEnabled(v bool) { global.SetOIDCEnabled(v) } +// OIDCIdpNameFlag returns the flag name for the 'OIDCIdpName' field +func OIDCIdpNameFlag() string { return "oidc-idp-name" } + // GetOIDCIdpName safely fetches the Configuration value for state's 'OIDCIdpName' field func (st *ConfigState) GetOIDCIdpName() (v string) { st.mutex.RLock() @@ -2097,15 +3972,15 @@ func (st *ConfigState) SetOIDCIdpName(v string) { st.reloadToViper() } -// OIDCIdpNameFlag returns the flag name for the 'OIDCIdpName' field -func OIDCIdpNameFlag() string { return "oidc-idp-name" } - // GetOIDCIdpName safely fetches the value for global configuration 'OIDCIdpName' field func GetOIDCIdpName() string { return global.GetOIDCIdpName() } // SetOIDCIdpName safely sets the value for global configuration 'OIDCIdpName' field func SetOIDCIdpName(v string) { global.SetOIDCIdpName(v) } +// OIDCSkipVerificationFlag returns the flag name for the 'OIDCSkipVerification' field +func OIDCSkipVerificationFlag() string { return "oidc-skip-verification" } + // GetOIDCSkipVerification safely fetches the Configuration value for state's 'OIDCSkipVerification' field func (st *ConfigState) GetOIDCSkipVerification() (v bool) { st.mutex.RLock() @@ -2122,15 +3997,15 @@ func (st *ConfigState) SetOIDCSkipVerification(v bool) { st.reloadToViper() } -// OIDCSkipVerificationFlag returns the flag name for the 'OIDCSkipVerification' field -func OIDCSkipVerificationFlag() string { return "oidc-skip-verification" } - // GetOIDCSkipVerification safely fetches the value for global configuration 'OIDCSkipVerification' field func GetOIDCSkipVerification() bool { return global.GetOIDCSkipVerification() } // SetOIDCSkipVerification safely sets the value for global configuration 'OIDCSkipVerification' field func SetOIDCSkipVerification(v bool) { global.SetOIDCSkipVerification(v) } +// OIDCIssuerFlag returns the flag name for the 'OIDCIssuer' field +func OIDCIssuerFlag() string { return "oidc-issuer" } + // GetOIDCIssuer safely fetches the Configuration value for state's 'OIDCIssuer' field func (st *ConfigState) GetOIDCIssuer() (v string) { st.mutex.RLock() @@ -2147,15 +4022,15 @@ func (st *ConfigState) SetOIDCIssuer(v string) { st.reloadToViper() } -// OIDCIssuerFlag returns the flag name for the 'OIDCIssuer' field -func OIDCIssuerFlag() string { return "oidc-issuer" } - // GetOIDCIssuer safely fetches the value for global configuration 'OIDCIssuer' field func GetOIDCIssuer() string { return global.GetOIDCIssuer() } // SetOIDCIssuer safely sets the value for global configuration 'OIDCIssuer' field func SetOIDCIssuer(v string) { global.SetOIDCIssuer(v) } +// OIDCClientIDFlag returns the flag name for the 'OIDCClientID' field +func OIDCClientIDFlag() string { return "oidc-client-id" } + // GetOIDCClientID safely fetches the Configuration value for state's 'OIDCClientID' field func (st *ConfigState) GetOIDCClientID() (v string) { st.mutex.RLock() @@ -2172,15 +4047,15 @@ func (st *ConfigState) SetOIDCClientID(v string) { st.reloadToViper() } -// OIDCClientIDFlag returns the flag name for the 'OIDCClientID' field -func OIDCClientIDFlag() string { return "oidc-client-id" } - // GetOIDCClientID safely fetches the value for global configuration 'OIDCClientID' field func GetOIDCClientID() string { return global.GetOIDCClientID() } // SetOIDCClientID safely sets the value for global configuration 'OIDCClientID' field func SetOIDCClientID(v string) { global.SetOIDCClientID(v) } +// OIDCClientSecretFlag returns the flag name for the 'OIDCClientSecret' field +func OIDCClientSecretFlag() string { return "oidc-client-secret" } + // GetOIDCClientSecret safely fetches the Configuration value for state's 'OIDCClientSecret' field func (st *ConfigState) GetOIDCClientSecret() (v string) { st.mutex.RLock() @@ -2197,15 +4072,15 @@ func (st *ConfigState) SetOIDCClientSecret(v string) { st.reloadToViper() } -// OIDCClientSecretFlag returns the flag name for the 'OIDCClientSecret' field -func OIDCClientSecretFlag() string { return "oidc-client-secret" } - // GetOIDCClientSecret safely fetches the value for global configuration 'OIDCClientSecret' field func GetOIDCClientSecret() string { return global.GetOIDCClientSecret() } // SetOIDCClientSecret safely sets the value for global configuration 'OIDCClientSecret' field func SetOIDCClientSecret(v string) { global.SetOIDCClientSecret(v) } +// OIDCScopesFlag returns the flag name for the 'OIDCScopes' field +func OIDCScopesFlag() string { return "oidc-scopes" } + // GetOIDCScopes safely fetches the Configuration value for state's 'OIDCScopes' field func (st *ConfigState) GetOIDCScopes() (v []string) { st.mutex.RLock() @@ -2222,15 +4097,15 @@ func (st *ConfigState) SetOIDCScopes(v []string) { st.reloadToViper() } -// OIDCScopesFlag returns the flag name for the 'OIDCScopes' field -func OIDCScopesFlag() string { return "oidc-scopes" } - // GetOIDCScopes safely fetches the value for global configuration 'OIDCScopes' field func GetOIDCScopes() []string { return global.GetOIDCScopes() } // SetOIDCScopes safely sets the value for global configuration 'OIDCScopes' field func SetOIDCScopes(v []string) { global.SetOIDCScopes(v) } +// OIDCLinkExistingFlag returns the flag name for the 'OIDCLinkExisting' field +func OIDCLinkExistingFlag() string { return "oidc-link-existing" } + // GetOIDCLinkExisting safely fetches the Configuration value for state's 'OIDCLinkExisting' field func (st *ConfigState) GetOIDCLinkExisting() (v bool) { st.mutex.RLock() @@ -2247,15 +4122,15 @@ func (st *ConfigState) SetOIDCLinkExisting(v bool) { st.reloadToViper() } -// OIDCLinkExistingFlag returns the flag name for the 'OIDCLinkExisting' field -func OIDCLinkExistingFlag() string { return "oidc-link-existing" } - // GetOIDCLinkExisting safely fetches the value for global configuration 'OIDCLinkExisting' field func GetOIDCLinkExisting() bool { return global.GetOIDCLinkExisting() } // SetOIDCLinkExisting safely sets the value for global configuration 'OIDCLinkExisting' field func SetOIDCLinkExisting(v bool) { global.SetOIDCLinkExisting(v) } +// OIDCAllowedGroupsFlag returns the flag name for the 'OIDCAllowedGroups' field +func OIDCAllowedGroupsFlag() string { return "oidc-allowed-groups" } + // GetOIDCAllowedGroups safely fetches the Configuration value for state's 'OIDCAllowedGroups' field func (st *ConfigState) GetOIDCAllowedGroups() (v []string) { st.mutex.RLock() @@ -2272,15 +4147,15 @@ func (st *ConfigState) SetOIDCAllowedGroups(v []string) { st.reloadToViper() } -// OIDCAllowedGroupsFlag returns the flag name for the 'OIDCAllowedGroups' field -func OIDCAllowedGroupsFlag() string { return "oidc-allowed-groups" } - // GetOIDCAllowedGroups safely fetches the value for global configuration 'OIDCAllowedGroups' field func GetOIDCAllowedGroups() []string { return global.GetOIDCAllowedGroups() } // SetOIDCAllowedGroups safely sets the value for global configuration 'OIDCAllowedGroups' field func SetOIDCAllowedGroups(v []string) { global.SetOIDCAllowedGroups(v) } +// OIDCAdminGroupsFlag returns the flag name for the 'OIDCAdminGroups' field +func OIDCAdminGroupsFlag() string { return "oidc-admin-groups" } + // GetOIDCAdminGroups safely fetches the Configuration value for state's 'OIDCAdminGroups' field func (st *ConfigState) GetOIDCAdminGroups() (v []string) { st.mutex.RLock() @@ -2297,15 +4172,15 @@ func (st *ConfigState) SetOIDCAdminGroups(v []string) { st.reloadToViper() } -// OIDCAdminGroupsFlag returns the flag name for the 'OIDCAdminGroups' field -func OIDCAdminGroupsFlag() string { return "oidc-admin-groups" } - // GetOIDCAdminGroups safely fetches the value for global configuration 'OIDCAdminGroups' field func GetOIDCAdminGroups() []string { return global.GetOIDCAdminGroups() } // SetOIDCAdminGroups safely sets the value for global configuration 'OIDCAdminGroups' field func SetOIDCAdminGroups(v []string) { global.SetOIDCAdminGroups(v) } +// TracingEnabledFlag returns the flag name for the 'TracingEnabled' field +func TracingEnabledFlag() string { return "tracing-enabled" } + // GetTracingEnabled safely fetches the Configuration value for state's 'TracingEnabled' field func (st *ConfigState) GetTracingEnabled() (v bool) { st.mutex.RLock() @@ -2322,15 +4197,15 @@ func (st *ConfigState) SetTracingEnabled(v bool) { st.reloadToViper() } -// TracingEnabledFlag returns the flag name for the 'TracingEnabled' field -func TracingEnabledFlag() string { return "tracing-enabled" } - // GetTracingEnabled safely fetches the value for global configuration 'TracingEnabled' field func GetTracingEnabled() bool { return global.GetTracingEnabled() } // SetTracingEnabled safely sets the value for global configuration 'TracingEnabled' field func SetTracingEnabled(v bool) { global.SetTracingEnabled(v) } +// MetricsEnabledFlag returns the flag name for the 'MetricsEnabled' field +func MetricsEnabledFlag() string { return "metrics-enabled" } + // GetMetricsEnabled safely fetches the Configuration value for state's 'MetricsEnabled' field func (st *ConfigState) GetMetricsEnabled() (v bool) { st.mutex.RLock() @@ -2347,15 +4222,15 @@ func (st *ConfigState) SetMetricsEnabled(v bool) { st.reloadToViper() } -// MetricsEnabledFlag returns the flag name for the 'MetricsEnabled' field -func MetricsEnabledFlag() string { return "metrics-enabled" } - // GetMetricsEnabled safely fetches the value for global configuration 'MetricsEnabled' field func GetMetricsEnabled() bool { return global.GetMetricsEnabled() } // SetMetricsEnabled safely sets the value for global configuration 'MetricsEnabled' field func SetMetricsEnabled(v bool) { global.SetMetricsEnabled(v) } +// SMTPHostFlag returns the flag name for the 'SMTPHost' field +func SMTPHostFlag() string { return "smtp-host" } + // GetSMTPHost safely fetches the Configuration value for state's 'SMTPHost' field func (st *ConfigState) GetSMTPHost() (v string) { st.mutex.RLock() @@ -2372,15 +4247,15 @@ func (st *ConfigState) SetSMTPHost(v string) { st.reloadToViper() } -// SMTPHostFlag returns the flag name for the 'SMTPHost' field -func SMTPHostFlag() string { return "smtp-host" } - // GetSMTPHost safely fetches the value for global configuration 'SMTPHost' field func GetSMTPHost() string { return global.GetSMTPHost() } // SetSMTPHost safely sets the value for global configuration 'SMTPHost' field func SetSMTPHost(v string) { global.SetSMTPHost(v) } +// SMTPPortFlag returns the flag name for the 'SMTPPort' field +func SMTPPortFlag() string { return "smtp-port" } + // GetSMTPPort safely fetches the Configuration value for state's 'SMTPPort' field func (st *ConfigState) GetSMTPPort() (v int) { st.mutex.RLock() @@ -2397,15 +4272,15 @@ func (st *ConfigState) SetSMTPPort(v int) { st.reloadToViper() } -// SMTPPortFlag returns the flag name for the 'SMTPPort' field -func SMTPPortFlag() string { return "smtp-port" } - // GetSMTPPort safely fetches the value for global configuration 'SMTPPort' field func GetSMTPPort() int { return global.GetSMTPPort() } // SetSMTPPort safely sets the value for global configuration 'SMTPPort' field func SetSMTPPort(v int) { global.SetSMTPPort(v) } +// SMTPUsernameFlag returns the flag name for the 'SMTPUsername' field +func SMTPUsernameFlag() string { return "smtp-username" } + // GetSMTPUsername safely fetches the Configuration value for state's 'SMTPUsername' field func (st *ConfigState) GetSMTPUsername() (v string) { st.mutex.RLock() @@ -2422,15 +4297,15 @@ func (st *ConfigState) SetSMTPUsername(v string) { st.reloadToViper() } -// SMTPUsernameFlag returns the flag name for the 'SMTPUsername' field -func SMTPUsernameFlag() string { return "smtp-username" } - // GetSMTPUsername safely fetches the value for global configuration 'SMTPUsername' field func GetSMTPUsername() string { return global.GetSMTPUsername() } // SetSMTPUsername safely sets the value for global configuration 'SMTPUsername' field func SetSMTPUsername(v string) { global.SetSMTPUsername(v) } +// SMTPPasswordFlag returns the flag name for the 'SMTPPassword' field +func SMTPPasswordFlag() string { return "smtp-password" } + // GetSMTPPassword safely fetches the Configuration value for state's 'SMTPPassword' field func (st *ConfigState) GetSMTPPassword() (v string) { st.mutex.RLock() @@ -2447,15 +4322,15 @@ func (st *ConfigState) SetSMTPPassword(v string) { st.reloadToViper() } -// SMTPPasswordFlag returns the flag name for the 'SMTPPassword' field -func SMTPPasswordFlag() string { return "smtp-password" } - // GetSMTPPassword safely fetches the value for global configuration 'SMTPPassword' field func GetSMTPPassword() string { return global.GetSMTPPassword() } // SetSMTPPassword safely sets the value for global configuration 'SMTPPassword' field func SetSMTPPassword(v string) { global.SetSMTPPassword(v) } +// SMTPFromFlag returns the flag name for the 'SMTPFrom' field +func SMTPFromFlag() string { return "smtp-from" } + // GetSMTPFrom safely fetches the Configuration value for state's 'SMTPFrom' field func (st *ConfigState) GetSMTPFrom() (v string) { st.mutex.RLock() @@ -2472,15 +4347,15 @@ func (st *ConfigState) SetSMTPFrom(v string) { st.reloadToViper() } -// SMTPFromFlag returns the flag name for the 'SMTPFrom' field -func SMTPFromFlag() string { return "smtp-from" } - // GetSMTPFrom safely fetches the value for global configuration 'SMTPFrom' field func GetSMTPFrom() string { return global.GetSMTPFrom() } // SetSMTPFrom safely sets the value for global configuration 'SMTPFrom' field func SetSMTPFrom(v string) { global.SetSMTPFrom(v) } +// SMTPDiscloseRecipientsFlag returns the flag name for the 'SMTPDiscloseRecipients' field +func SMTPDiscloseRecipientsFlag() string { return "smtp-disclose-recipients" } + // GetSMTPDiscloseRecipients safely fetches the Configuration value for state's 'SMTPDiscloseRecipients' field func (st *ConfigState) GetSMTPDiscloseRecipients() (v bool) { st.mutex.RLock() @@ -2497,15 +4372,15 @@ func (st *ConfigState) SetSMTPDiscloseRecipients(v bool) { st.reloadToViper() } -// SMTPDiscloseRecipientsFlag returns the flag name for the 'SMTPDiscloseRecipients' field -func SMTPDiscloseRecipientsFlag() string { return "smtp-disclose-recipients" } - // GetSMTPDiscloseRecipients safely fetches the value for global configuration 'SMTPDiscloseRecipients' field func GetSMTPDiscloseRecipients() bool { return global.GetSMTPDiscloseRecipients() } // SetSMTPDiscloseRecipients safely sets the value for global configuration 'SMTPDiscloseRecipients' field func SetSMTPDiscloseRecipients(v bool) { global.SetSMTPDiscloseRecipients(v) } +// SyslogEnabledFlag returns the flag name for the 'SyslogEnabled' field +func SyslogEnabledFlag() string { return "syslog-enabled" } + // GetSyslogEnabled safely fetches the Configuration value for state's 'SyslogEnabled' field func (st *ConfigState) GetSyslogEnabled() (v bool) { st.mutex.RLock() @@ -2522,15 +4397,15 @@ func (st *ConfigState) SetSyslogEnabled(v bool) { st.reloadToViper() } -// SyslogEnabledFlag returns the flag name for the 'SyslogEnabled' field -func SyslogEnabledFlag() string { return "syslog-enabled" } - // GetSyslogEnabled safely fetches the value for global configuration 'SyslogEnabled' field func GetSyslogEnabled() bool { return global.GetSyslogEnabled() } // SetSyslogEnabled safely sets the value for global configuration 'SyslogEnabled' field func SetSyslogEnabled(v bool) { global.SetSyslogEnabled(v) } +// SyslogProtocolFlag returns the flag name for the 'SyslogProtocol' field +func SyslogProtocolFlag() string { return "syslog-protocol" } + // GetSyslogProtocol safely fetches the Configuration value for state's 'SyslogProtocol' field func (st *ConfigState) GetSyslogProtocol() (v string) { st.mutex.RLock() @@ -2547,15 +4422,15 @@ func (st *ConfigState) SetSyslogProtocol(v string) { st.reloadToViper() } -// SyslogProtocolFlag returns the flag name for the 'SyslogProtocol' field -func SyslogProtocolFlag() string { return "syslog-protocol" } - // GetSyslogProtocol safely fetches the value for global configuration 'SyslogProtocol' field func GetSyslogProtocol() string { return global.GetSyslogProtocol() } // SetSyslogProtocol safely sets the value for global configuration 'SyslogProtocol' field func SetSyslogProtocol(v string) { global.SetSyslogProtocol(v) } +// SyslogAddressFlag returns the flag name for the 'SyslogAddress' field +func SyslogAddressFlag() string { return "syslog-address" } + // GetSyslogAddress safely fetches the Configuration value for state's 'SyslogAddress' field func (st *ConfigState) GetSyslogAddress() (v string) { st.mutex.RLock() @@ -2572,239 +4447,239 @@ func (st *ConfigState) SetSyslogAddress(v string) { st.reloadToViper() } -// SyslogAddressFlag returns the flag name for the 'SyslogAddress' field -func SyslogAddressFlag() string { return "syslog-address" } - // GetSyslogAddress safely fetches the value for global configuration 'SyslogAddress' field func GetSyslogAddress() string { return global.GetSyslogAddress() } // SetSyslogAddress safely sets the value for global configuration 'SyslogAddress' field func SetSyslogAddress(v string) { global.SetSyslogAddress(v) } -// GetAdvancedCookiesSamesite safely fetches the Configuration value for state's 'AdvancedCookiesSamesite' field +// AdvancedCookiesSamesiteFlag returns the flag name for the 'Advanced.CookiesSamesite' field +func AdvancedCookiesSamesiteFlag() string { return "advanced-cookies-samesite" } + +// GetAdvancedCookiesSamesite safely fetches the Configuration value for state's 'Advanced.CookiesSamesite' field func (st *ConfigState) GetAdvancedCookiesSamesite() (v string) { st.mutex.RLock() - v = st.config.AdvancedCookiesSamesite + v = st.config.Advanced.CookiesSamesite st.mutex.RUnlock() return } -// SetAdvancedCookiesSamesite safely sets the Configuration value for state's 'AdvancedCookiesSamesite' field +// SetAdvancedCookiesSamesite safely sets the Configuration value for state's 'Advanced.CookiesSamesite' field func (st *ConfigState) SetAdvancedCookiesSamesite(v string) { st.mutex.Lock() defer st.mutex.Unlock() - st.config.AdvancedCookiesSamesite = v + st.config.Advanced.CookiesSamesite = v st.reloadToViper() } -// AdvancedCookiesSamesiteFlag returns the flag name for the 'AdvancedCookiesSamesite' field -func AdvancedCookiesSamesiteFlag() string { return "advanced-cookies-samesite" } - -// GetAdvancedCookiesSamesite safely fetches the value for global configuration 'AdvancedCookiesSamesite' field +// GetAdvancedCookiesSamesite safely fetches the value for global configuration 'Advanced.CookiesSamesite' field func GetAdvancedCookiesSamesite() string { return global.GetAdvancedCookiesSamesite() } -// SetAdvancedCookiesSamesite safely sets the value for global configuration 'AdvancedCookiesSamesite' field +// SetAdvancedCookiesSamesite safely sets the value for global configuration 'Advanced.CookiesSamesite' field func SetAdvancedCookiesSamesite(v string) { global.SetAdvancedCookiesSamesite(v) } -// GetAdvancedRateLimitRequests safely fetches the Configuration value for state's 'AdvancedRateLimitRequests' field -func (st *ConfigState) GetAdvancedRateLimitRequests() (v int) { +// AdvancedSenderMultiplierFlag returns the flag name for the 'Advanced.SenderMultiplier' field +func AdvancedSenderMultiplierFlag() string { return "advanced-sender-multiplier" } + +// GetAdvancedSenderMultiplier safely fetches the Configuration value for state's 'Advanced.SenderMultiplier' field +func (st *ConfigState) GetAdvancedSenderMultiplier() (v int) { st.mutex.RLock() - v = st.config.AdvancedRateLimitRequests + v = st.config.Advanced.SenderMultiplier st.mutex.RUnlock() return } -// SetAdvancedRateLimitRequests safely sets the Configuration value for state's 'AdvancedRateLimitRequests' field -func (st *ConfigState) SetAdvancedRateLimitRequests(v int) { +// SetAdvancedSenderMultiplier safely sets the Configuration value for state's 'Advanced.SenderMultiplier' field +func (st *ConfigState) SetAdvancedSenderMultiplier(v int) { st.mutex.Lock() defer st.mutex.Unlock() - st.config.AdvancedRateLimitRequests = v + st.config.Advanced.SenderMultiplier = v st.reloadToViper() } -// AdvancedRateLimitRequestsFlag returns the flag name for the 'AdvancedRateLimitRequests' field -func AdvancedRateLimitRequestsFlag() string { return "advanced-rate-limit-requests" } +// GetAdvancedSenderMultiplier safely fetches the value for global configuration 'Advanced.SenderMultiplier' field +func GetAdvancedSenderMultiplier() int { return global.GetAdvancedSenderMultiplier() } -// GetAdvancedRateLimitRequests safely fetches the value for global configuration 'AdvancedRateLimitRequests' field -func GetAdvancedRateLimitRequests() int { return global.GetAdvancedRateLimitRequests() } +// SetAdvancedSenderMultiplier safely sets the value for global configuration 'Advanced.SenderMultiplier' field +func SetAdvancedSenderMultiplier(v int) { global.SetAdvancedSenderMultiplier(v) } -// SetAdvancedRateLimitRequests safely sets the value for global configuration 'AdvancedRateLimitRequests' field -func SetAdvancedRateLimitRequests(v int) { global.SetAdvancedRateLimitRequests(v) } +// AdvancedCSPExtraURIsFlag returns the flag name for the 'Advanced.CSPExtraURIs' field +func AdvancedCSPExtraURIsFlag() string { return "advanced-csp-extra-uris" } -// GetAdvancedRateLimitExceptions safely fetches the Configuration value for state's 'AdvancedRateLimitExceptions' field -func (st *ConfigState) GetAdvancedRateLimitExceptions() (v IPPrefixes) { +// GetAdvancedCSPExtraURIs safely fetches the Configuration value for state's 'Advanced.CSPExtraURIs' field +func (st *ConfigState) GetAdvancedCSPExtraURIs() (v []string) { st.mutex.RLock() - v = st.config.AdvancedRateLimitExceptions + v = st.config.Advanced.CSPExtraURIs st.mutex.RUnlock() return } -// SetAdvancedRateLimitExceptions safely sets the Configuration value for state's 'AdvancedRateLimitExceptions' field -func (st *ConfigState) SetAdvancedRateLimitExceptions(v IPPrefixes) { +// SetAdvancedCSPExtraURIs safely sets the Configuration value for state's 'Advanced.CSPExtraURIs' field +func (st *ConfigState) SetAdvancedCSPExtraURIs(v []string) { st.mutex.Lock() defer st.mutex.Unlock() - st.config.AdvancedRateLimitExceptions = v + st.config.Advanced.CSPExtraURIs = v st.reloadToViper() } -// AdvancedRateLimitExceptionsFlag returns the flag name for the 'AdvancedRateLimitExceptions' field -func AdvancedRateLimitExceptionsFlag() string { return "advanced-rate-limit-exceptions" } +// GetAdvancedCSPExtraURIs safely fetches the value for global configuration 'Advanced.CSPExtraURIs' field +func GetAdvancedCSPExtraURIs() []string { return global.GetAdvancedCSPExtraURIs() } -// GetAdvancedRateLimitExceptions safely fetches the value for global configuration 'AdvancedRateLimitExceptions' field -func GetAdvancedRateLimitExceptions() IPPrefixes { return global.GetAdvancedRateLimitExceptions() } +// SetAdvancedCSPExtraURIs safely sets the value for global configuration 'Advanced.CSPExtraURIs' field +func SetAdvancedCSPExtraURIs(v []string) { global.SetAdvancedCSPExtraURIs(v) } -// SetAdvancedRateLimitExceptions safely sets the value for global configuration 'AdvancedRateLimitExceptions' field -func SetAdvancedRateLimitExceptions(v IPPrefixes) { global.SetAdvancedRateLimitExceptions(v) } +// AdvancedHeaderFilterModeFlag returns the flag name for the 'Advanced.HeaderFilterMode' field +func AdvancedHeaderFilterModeFlag() string { return "advanced-header-filter-mode" } -// GetAdvancedThrottlingMultiplier safely fetches the Configuration value for state's 'AdvancedThrottlingMultiplier' field -func (st *ConfigState) GetAdvancedThrottlingMultiplier() (v int) { +// GetAdvancedHeaderFilterMode safely fetches the Configuration value for state's 'Advanced.HeaderFilterMode' field +func (st *ConfigState) GetAdvancedHeaderFilterMode() (v string) { st.mutex.RLock() - v = st.config.AdvancedThrottlingMultiplier + v = st.config.Advanced.HeaderFilterMode st.mutex.RUnlock() return } -// SetAdvancedThrottlingMultiplier safely sets the Configuration value for state's 'AdvancedThrottlingMultiplier' field -func (st *ConfigState) SetAdvancedThrottlingMultiplier(v int) { +// SetAdvancedHeaderFilterMode safely sets the Configuration value for state's 'Advanced.HeaderFilterMode' field +func (st *ConfigState) SetAdvancedHeaderFilterMode(v string) { st.mutex.Lock() defer st.mutex.Unlock() - st.config.AdvancedThrottlingMultiplier = v + st.config.Advanced.HeaderFilterMode = v st.reloadToViper() } -// AdvancedThrottlingMultiplierFlag returns the flag name for the 'AdvancedThrottlingMultiplier' field -func AdvancedThrottlingMultiplierFlag() string { return "advanced-throttling-multiplier" } +// GetAdvancedHeaderFilterMode safely fetches the value for global configuration 'Advanced.HeaderFilterMode' field +func GetAdvancedHeaderFilterMode() string { return global.GetAdvancedHeaderFilterMode() } -// GetAdvancedThrottlingMultiplier safely fetches the value for global configuration 'AdvancedThrottlingMultiplier' field -func GetAdvancedThrottlingMultiplier() int { return global.GetAdvancedThrottlingMultiplier() } +// SetAdvancedHeaderFilterMode safely sets the value for global configuration 'Advanced.HeaderFilterMode' field +func SetAdvancedHeaderFilterMode(v string) { global.SetAdvancedHeaderFilterMode(v) } -// SetAdvancedThrottlingMultiplier safely sets the value for global configuration 'AdvancedThrottlingMultiplier' field -func SetAdvancedThrottlingMultiplier(v int) { global.SetAdvancedThrottlingMultiplier(v) } +// AdvancedScraperDeterrenceFlag returns the flag name for the 'Advanced.ScraperDeterrence' field +func AdvancedScraperDeterrenceFlag() string { return "advanced-scraper-deterrence" } -// GetAdvancedThrottlingRetryAfter safely fetches the Configuration value for state's 'AdvancedThrottlingRetryAfter' field -func (st *ConfigState) GetAdvancedThrottlingRetryAfter() (v time.Duration) { +// GetAdvancedScraperDeterrence safely fetches the Configuration value for state's 'Advanced.ScraperDeterrence' field +func (st *ConfigState) GetAdvancedScraperDeterrence() (v bool) { st.mutex.RLock() - v = st.config.AdvancedThrottlingRetryAfter + v = st.config.Advanced.ScraperDeterrence st.mutex.RUnlock() return } -// SetAdvancedThrottlingRetryAfter safely sets the Configuration value for state's 'AdvancedThrottlingRetryAfter' field -func (st *ConfigState) SetAdvancedThrottlingRetryAfter(v time.Duration) { +// SetAdvancedScraperDeterrence safely sets the Configuration value for state's 'Advanced.ScraperDeterrence' field +func (st *ConfigState) SetAdvancedScraperDeterrence(v bool) { st.mutex.Lock() defer st.mutex.Unlock() - st.config.AdvancedThrottlingRetryAfter = v + st.config.Advanced.ScraperDeterrence = v st.reloadToViper() } -// AdvancedThrottlingRetryAfterFlag returns the flag name for the 'AdvancedThrottlingRetryAfter' field -func AdvancedThrottlingRetryAfterFlag() string { return "advanced-throttling-retry-after" } +// GetAdvancedScraperDeterrence safely fetches the value for global configuration 'Advanced.ScraperDeterrence' field +func GetAdvancedScraperDeterrence() bool { return global.GetAdvancedScraperDeterrence() } -// GetAdvancedThrottlingRetryAfter safely fetches the value for global configuration 'AdvancedThrottlingRetryAfter' field -func GetAdvancedThrottlingRetryAfter() time.Duration { return global.GetAdvancedThrottlingRetryAfter() } +// SetAdvancedScraperDeterrence safely sets the value for global configuration 'Advanced.ScraperDeterrence' field +func SetAdvancedScraperDeterrence(v bool) { global.SetAdvancedScraperDeterrence(v) } -// SetAdvancedThrottlingRetryAfter safely sets the value for global configuration 'AdvancedThrottlingRetryAfter' field -func SetAdvancedThrottlingRetryAfter(v time.Duration) { global.SetAdvancedThrottlingRetryAfter(v) } +// AdvancedRateLimitRequestsFlag returns the flag name for the 'Advanced.RateLimit.Requests' field +func AdvancedRateLimitRequestsFlag() string { return "advanced-rate-limit-requests" } -// GetAdvancedSenderMultiplier safely fetches the Configuration value for state's 'AdvancedSenderMultiplier' field -func (st *ConfigState) GetAdvancedSenderMultiplier() (v int) { +// GetAdvancedRateLimitRequests safely fetches the Configuration value for state's 'Advanced.RateLimit.Requests' field +func (st *ConfigState) GetAdvancedRateLimitRequests() (v int) { st.mutex.RLock() - v = st.config.AdvancedSenderMultiplier + v = st.config.Advanced.RateLimit.Requests st.mutex.RUnlock() return } -// SetAdvancedSenderMultiplier safely sets the Configuration value for state's 'AdvancedSenderMultiplier' field -func (st *ConfigState) SetAdvancedSenderMultiplier(v int) { +// SetAdvancedRateLimitRequests safely sets the Configuration value for state's 'Advanced.RateLimit.Requests' field +func (st *ConfigState) SetAdvancedRateLimitRequests(v int) { st.mutex.Lock() defer st.mutex.Unlock() - st.config.AdvancedSenderMultiplier = v + st.config.Advanced.RateLimit.Requests = v st.reloadToViper() } -// AdvancedSenderMultiplierFlag returns the flag name for the 'AdvancedSenderMultiplier' field -func AdvancedSenderMultiplierFlag() string { return "advanced-sender-multiplier" } +// GetAdvancedRateLimitRequests safely fetches the value for global configuration 'Advanced.RateLimit.Requests' field +func GetAdvancedRateLimitRequests() int { return global.GetAdvancedRateLimitRequests() } -// GetAdvancedSenderMultiplier safely fetches the value for global configuration 'AdvancedSenderMultiplier' field -func GetAdvancedSenderMultiplier() int { return global.GetAdvancedSenderMultiplier() } +// SetAdvancedRateLimitRequests safely sets the value for global configuration 'Advanced.RateLimit.Requests' field +func SetAdvancedRateLimitRequests(v int) { global.SetAdvancedRateLimitRequests(v) } -// SetAdvancedSenderMultiplier safely sets the value for global configuration 'AdvancedSenderMultiplier' field -func SetAdvancedSenderMultiplier(v int) { global.SetAdvancedSenderMultiplier(v) } +// AdvancedRateLimitExceptionsFlag returns the flag name for the 'Advanced.RateLimit.Exceptions' field +func AdvancedRateLimitExceptionsFlag() string { return "advanced-rate-limit-exceptions" } -// GetAdvancedCSPExtraURIs safely fetches the Configuration value for state's 'AdvancedCSPExtraURIs' field -func (st *ConfigState) GetAdvancedCSPExtraURIs() (v []string) { +// GetAdvancedRateLimitExceptions safely fetches the Configuration value for state's 'Advanced.RateLimit.Exceptions' field +func (st *ConfigState) GetAdvancedRateLimitExceptions() (v IPPrefixes) { st.mutex.RLock() - v = st.config.AdvancedCSPExtraURIs + v = st.config.Advanced.RateLimit.Exceptions st.mutex.RUnlock() return } -// SetAdvancedCSPExtraURIs safely sets the Configuration value for state's 'AdvancedCSPExtraURIs' field -func (st *ConfigState) SetAdvancedCSPExtraURIs(v []string) { +// SetAdvancedRateLimitExceptions safely sets the Configuration value for state's 'Advanced.RateLimit.Exceptions' field +func (st *ConfigState) SetAdvancedRateLimitExceptions(v IPPrefixes) { st.mutex.Lock() defer st.mutex.Unlock() - st.config.AdvancedCSPExtraURIs = v + st.config.Advanced.RateLimit.Exceptions = v st.reloadToViper() } -// AdvancedCSPExtraURIsFlag returns the flag name for the 'AdvancedCSPExtraURIs' field -func AdvancedCSPExtraURIsFlag() string { return "advanced-csp-extra-uris" } +// GetAdvancedRateLimitExceptions safely fetches the value for global configuration 'Advanced.RateLimit.Exceptions' field +func GetAdvancedRateLimitExceptions() IPPrefixes { return global.GetAdvancedRateLimitExceptions() } -// GetAdvancedCSPExtraURIs safely fetches the value for global configuration 'AdvancedCSPExtraURIs' field -func GetAdvancedCSPExtraURIs() []string { return global.GetAdvancedCSPExtraURIs() } +// SetAdvancedRateLimitExceptions safely sets the value for global configuration 'Advanced.RateLimit.Exceptions' field +func SetAdvancedRateLimitExceptions(v IPPrefixes) { global.SetAdvancedRateLimitExceptions(v) } -// SetAdvancedCSPExtraURIs safely sets the value for global configuration 'AdvancedCSPExtraURIs' field -func SetAdvancedCSPExtraURIs(v []string) { global.SetAdvancedCSPExtraURIs(v) } +// AdvancedThrottlingMultiplierFlag returns the flag name for the 'Advanced.Throttling.Multiplier' field +func AdvancedThrottlingMultiplierFlag() string { return "advanced-throttling-multiplier" } -// GetAdvancedHeaderFilterMode safely fetches the Configuration value for state's 'AdvancedHeaderFilterMode' field -func (st *ConfigState) GetAdvancedHeaderFilterMode() (v string) { +// GetAdvancedThrottlingMultiplier safely fetches the Configuration value for state's 'Advanced.Throttling.Multiplier' field +func (st *ConfigState) GetAdvancedThrottlingMultiplier() (v int) { st.mutex.RLock() - v = st.config.AdvancedHeaderFilterMode + v = st.config.Advanced.Throttling.Multiplier st.mutex.RUnlock() return } -// SetAdvancedHeaderFilterMode safely sets the Configuration value for state's 'AdvancedHeaderFilterMode' field -func (st *ConfigState) SetAdvancedHeaderFilterMode(v string) { +// SetAdvancedThrottlingMultiplier safely sets the Configuration value for state's 'Advanced.Throttling.Multiplier' field +func (st *ConfigState) SetAdvancedThrottlingMultiplier(v int) { st.mutex.Lock() defer st.mutex.Unlock() - st.config.AdvancedHeaderFilterMode = v + st.config.Advanced.Throttling.Multiplier = v st.reloadToViper() } -// AdvancedHeaderFilterModeFlag returns the flag name for the 'AdvancedHeaderFilterMode' field -func AdvancedHeaderFilterModeFlag() string { return "advanced-header-filter-mode" } +// GetAdvancedThrottlingMultiplier safely fetches the value for global configuration 'Advanced.Throttling.Multiplier' field +func GetAdvancedThrottlingMultiplier() int { return global.GetAdvancedThrottlingMultiplier() } -// GetAdvancedHeaderFilterMode safely fetches the value for global configuration 'AdvancedHeaderFilterMode' field -func GetAdvancedHeaderFilterMode() string { return global.GetAdvancedHeaderFilterMode() } +// SetAdvancedThrottlingMultiplier safely sets the value for global configuration 'Advanced.Throttling.Multiplier' field +func SetAdvancedThrottlingMultiplier(v int) { global.SetAdvancedThrottlingMultiplier(v) } -// SetAdvancedHeaderFilterMode safely sets the value for global configuration 'AdvancedHeaderFilterMode' field -func SetAdvancedHeaderFilterMode(v string) { global.SetAdvancedHeaderFilterMode(v) } +// AdvancedThrottlingRetryAfterFlag returns the flag name for the 'Advanced.Throttling.RetryAfter' field +func AdvancedThrottlingRetryAfterFlag() string { return "advanced-throttling-retry-after" } -// GetAdvancedScraperDeterrence safely fetches the Configuration value for state's 'AdvancedScraperDeterrence' field -func (st *ConfigState) GetAdvancedScraperDeterrence() (v bool) { +// GetAdvancedThrottlingRetryAfter safely fetches the Configuration value for state's 'Advanced.Throttling.RetryAfter' field +func (st *ConfigState) GetAdvancedThrottlingRetryAfter() (v time.Duration) { st.mutex.RLock() - v = st.config.AdvancedScraperDeterrence + v = st.config.Advanced.Throttling.RetryAfter st.mutex.RUnlock() return } -// SetAdvancedScraperDeterrence safely sets the Configuration value for state's 'AdvancedScraperDeterrence' field -func (st *ConfigState) SetAdvancedScraperDeterrence(v bool) { +// SetAdvancedThrottlingRetryAfter safely sets the Configuration value for state's 'Advanced.Throttling.RetryAfter' field +func (st *ConfigState) SetAdvancedThrottlingRetryAfter(v time.Duration) { st.mutex.Lock() defer st.mutex.Unlock() - st.config.AdvancedScraperDeterrence = v + st.config.Advanced.Throttling.RetryAfter = v st.reloadToViper() } -// AdvancedScraperDeterrenceFlag returns the flag name for the 'AdvancedScraperDeterrence' field -func AdvancedScraperDeterrenceFlag() string { return "advanced-scraper-deterrence" } +// GetAdvancedThrottlingRetryAfter safely fetches the value for global configuration 'Advanced.Throttling.RetryAfter' field +func GetAdvancedThrottlingRetryAfter() time.Duration { return global.GetAdvancedThrottlingRetryAfter() } -// GetAdvancedScraperDeterrence safely fetches the value for global configuration 'AdvancedScraperDeterrence' field -func GetAdvancedScraperDeterrence() bool { return global.GetAdvancedScraperDeterrence() } +// SetAdvancedThrottlingRetryAfter safely sets the value for global configuration 'Advanced.Throttling.RetryAfter' field +func SetAdvancedThrottlingRetryAfter(v time.Duration) { global.SetAdvancedThrottlingRetryAfter(v) } -// SetAdvancedScraperDeterrence safely sets the value for global configuration 'AdvancedScraperDeterrence' field -func SetAdvancedScraperDeterrence(v bool) { global.SetAdvancedScraperDeterrence(v) } +// HTTPClientAllowIPsFlag returns the flag name for the 'HTTPClient.AllowIPs' field +func HTTPClientAllowIPsFlag() string { return "http-client-allow-ips" } // GetHTTPClientAllowIPs safely fetches the Configuration value for state's 'HTTPClient.AllowIPs' field func (st *ConfigState) GetHTTPClientAllowIPs() (v []string) { @@ -2822,15 +4697,15 @@ func (st *ConfigState) SetHTTPClientAllowIPs(v []string) { st.reloadToViper() } -// HTTPClientAllowIPsFlag returns the flag name for the 'HTTPClient.AllowIPs' field -func HTTPClientAllowIPsFlag() string { return "httpclient-allow-ips" } - // GetHTTPClientAllowIPs safely fetches the value for global configuration 'HTTPClient.AllowIPs' field func GetHTTPClientAllowIPs() []string { return global.GetHTTPClientAllowIPs() } // SetHTTPClientAllowIPs safely sets the value for global configuration 'HTTPClient.AllowIPs' field func SetHTTPClientAllowIPs(v []string) { global.SetHTTPClientAllowIPs(v) } +// HTTPClientBlockIPsFlag returns the flag name for the 'HTTPClient.BlockIPs' field +func HTTPClientBlockIPsFlag() string { return "http-client-block-ips" } + // GetHTTPClientBlockIPs safely fetches the Configuration value for state's 'HTTPClient.BlockIPs' field func (st *ConfigState) GetHTTPClientBlockIPs() (v []string) { st.mutex.RLock() @@ -2847,15 +4722,15 @@ func (st *ConfigState) SetHTTPClientBlockIPs(v []string) { st.reloadToViper() } -// HTTPClientBlockIPsFlag returns the flag name for the 'HTTPClient.BlockIPs' field -func HTTPClientBlockIPsFlag() string { return "httpclient-block-ips" } - // GetHTTPClientBlockIPs safely fetches the value for global configuration 'HTTPClient.BlockIPs' field func GetHTTPClientBlockIPs() []string { return global.GetHTTPClientBlockIPs() } // SetHTTPClientBlockIPs safely sets the value for global configuration 'HTTPClient.BlockIPs' field func SetHTTPClientBlockIPs(v []string) { global.SetHTTPClientBlockIPs(v) } +// HTTPClientTimeoutFlag returns the flag name for the 'HTTPClient.Timeout' field +func HTTPClientTimeoutFlag() string { return "http-client-timeout" } + // GetHTTPClientTimeout safely fetches the Configuration value for state's 'HTTPClient.Timeout' field func (st *ConfigState) GetHTTPClientTimeout() (v time.Duration) { st.mutex.RLock() @@ -2872,15 +4747,15 @@ func (st *ConfigState) SetHTTPClientTimeout(v time.Duration) { st.reloadToViper() } -// HTTPClientTimeoutFlag returns the flag name for the 'HTTPClient.Timeout' field -func HTTPClientTimeoutFlag() string { return "httpclient-timeout" } - // GetHTTPClientTimeout safely fetches the value for global configuration 'HTTPClient.Timeout' field func GetHTTPClientTimeout() time.Duration { return global.GetHTTPClientTimeout() } // SetHTTPClientTimeout safely sets the value for global configuration 'HTTPClient.Timeout' field func SetHTTPClientTimeout(v time.Duration) { global.SetHTTPClientTimeout(v) } +// HTTPClientTLSInsecureSkipVerifyFlag returns the flag name for the 'HTTPClient.TLSInsecureSkipVerify' field +func HTTPClientTLSInsecureSkipVerifyFlag() string { return "http-client-tls-insecure-skip-verify" } + // GetHTTPClientTLSInsecureSkipVerify safely fetches the Configuration value for state's 'HTTPClient.TLSInsecureSkipVerify' field func (st *ConfigState) GetHTTPClientTLSInsecureSkipVerify() (v bool) { st.mutex.RLock() @@ -2897,15 +4772,15 @@ func (st *ConfigState) SetHTTPClientTLSInsecureSkipVerify(v bool) { st.reloadToViper() } -// HTTPClientTLSInsecureSkipVerifyFlag returns the flag name for the 'HTTPClient.TLSInsecureSkipVerify' field -func HTTPClientTLSInsecureSkipVerifyFlag() string { return "httpclient-tls-insecure-skip-verify" } - // GetHTTPClientTLSInsecureSkipVerify safely fetches the value for global configuration 'HTTPClient.TLSInsecureSkipVerify' field func GetHTTPClientTLSInsecureSkipVerify() bool { return global.GetHTTPClientTLSInsecureSkipVerify() } // SetHTTPClientTLSInsecureSkipVerify safely sets the value for global configuration 'HTTPClient.TLSInsecureSkipVerify' field func SetHTTPClientTLSInsecureSkipVerify(v bool) { global.SetHTTPClientTLSInsecureSkipVerify(v) } +// CacheMemoryTargetFlag returns the flag name for the 'Cache.MemoryTarget' field +func CacheMemoryTargetFlag() string { return "cache-memory-target" } + // GetCacheMemoryTarget safely fetches the Configuration value for state's 'Cache.MemoryTarget' field func (st *ConfigState) GetCacheMemoryTarget() (v bytesize.Size) { st.mutex.RLock() @@ -2922,15 +4797,15 @@ func (st *ConfigState) SetCacheMemoryTarget(v bytesize.Size) { st.reloadToViper() } -// CacheMemoryTargetFlag returns the flag name for the 'Cache.MemoryTarget' field -func CacheMemoryTargetFlag() string { return "cache-memory-target" } - // GetCacheMemoryTarget safely fetches the value for global configuration 'Cache.MemoryTarget' field func GetCacheMemoryTarget() bytesize.Size { return global.GetCacheMemoryTarget() } // SetCacheMemoryTarget safely sets the value for global configuration 'Cache.MemoryTarget' field func SetCacheMemoryTarget(v bytesize.Size) { global.SetCacheMemoryTarget(v) } +// CacheAccountMemRatioFlag returns the flag name for the 'Cache.AccountMemRatio' field +func CacheAccountMemRatioFlag() string { return "cache-account-mem-ratio" } + // GetCacheAccountMemRatio safely fetches the Configuration value for state's 'Cache.AccountMemRatio' field func (st *ConfigState) GetCacheAccountMemRatio() (v float64) { st.mutex.RLock() @@ -2947,15 +4822,15 @@ func (st *ConfigState) SetCacheAccountMemRatio(v float64) { st.reloadToViper() } -// CacheAccountMemRatioFlag returns the flag name for the 'Cache.AccountMemRatio' field -func CacheAccountMemRatioFlag() string { return "cache-account-mem-ratio" } - // GetCacheAccountMemRatio safely fetches the value for global configuration 'Cache.AccountMemRatio' field func GetCacheAccountMemRatio() float64 { return global.GetCacheAccountMemRatio() } // SetCacheAccountMemRatio safely sets the value for global configuration 'Cache.AccountMemRatio' field func SetCacheAccountMemRatio(v float64) { global.SetCacheAccountMemRatio(v) } +// CacheAccountNoteMemRatioFlag returns the flag name for the 'Cache.AccountNoteMemRatio' field +func CacheAccountNoteMemRatioFlag() string { return "cache-account-note-mem-ratio" } + // GetCacheAccountNoteMemRatio safely fetches the Configuration value for state's 'Cache.AccountNoteMemRatio' field func (st *ConfigState) GetCacheAccountNoteMemRatio() (v float64) { st.mutex.RLock() @@ -2972,15 +4847,15 @@ func (st *ConfigState) SetCacheAccountNoteMemRatio(v float64) { st.reloadToViper() } -// CacheAccountNoteMemRatioFlag returns the flag name for the 'Cache.AccountNoteMemRatio' field -func CacheAccountNoteMemRatioFlag() string { return "cache-account-note-mem-ratio" } - // GetCacheAccountNoteMemRatio safely fetches the value for global configuration 'Cache.AccountNoteMemRatio' field func GetCacheAccountNoteMemRatio() float64 { return global.GetCacheAccountNoteMemRatio() } // SetCacheAccountNoteMemRatio safely sets the value for global configuration 'Cache.AccountNoteMemRatio' field func SetCacheAccountNoteMemRatio(v float64) { global.SetCacheAccountNoteMemRatio(v) } +// CacheAccountSettingsMemRatioFlag returns the flag name for the 'Cache.AccountSettingsMemRatio' field +func CacheAccountSettingsMemRatioFlag() string { return "cache-account-settings-mem-ratio" } + // GetCacheAccountSettingsMemRatio safely fetches the Configuration value for state's 'Cache.AccountSettingsMemRatio' field func (st *ConfigState) GetCacheAccountSettingsMemRatio() (v float64) { st.mutex.RLock() @@ -2997,15 +4872,15 @@ func (st *ConfigState) SetCacheAccountSettingsMemRatio(v float64) { st.reloadToViper() } -// CacheAccountSettingsMemRatioFlag returns the flag name for the 'Cache.AccountSettingsMemRatio' field -func CacheAccountSettingsMemRatioFlag() string { return "cache-account-settings-mem-ratio" } - // GetCacheAccountSettingsMemRatio safely fetches the value for global configuration 'Cache.AccountSettingsMemRatio' field func GetCacheAccountSettingsMemRatio() float64 { return global.GetCacheAccountSettingsMemRatio() } // SetCacheAccountSettingsMemRatio safely sets the value for global configuration 'Cache.AccountSettingsMemRatio' field func SetCacheAccountSettingsMemRatio(v float64) { global.SetCacheAccountSettingsMemRatio(v) } +// CacheAccountStatsMemRatioFlag returns the flag name for the 'Cache.AccountStatsMemRatio' field +func CacheAccountStatsMemRatioFlag() string { return "cache-account-stats-mem-ratio" } + // GetCacheAccountStatsMemRatio safely fetches the Configuration value for state's 'Cache.AccountStatsMemRatio' field func (st *ConfigState) GetCacheAccountStatsMemRatio() (v float64) { st.mutex.RLock() @@ -3022,15 +4897,15 @@ func (st *ConfigState) SetCacheAccountStatsMemRatio(v float64) { st.reloadToViper() } -// CacheAccountStatsMemRatioFlag returns the flag name for the 'Cache.AccountStatsMemRatio' field -func CacheAccountStatsMemRatioFlag() string { return "cache-account-stats-mem-ratio" } - // GetCacheAccountStatsMemRatio safely fetches the value for global configuration 'Cache.AccountStatsMemRatio' field func GetCacheAccountStatsMemRatio() float64 { return global.GetCacheAccountStatsMemRatio() } // SetCacheAccountStatsMemRatio safely sets the value for global configuration 'Cache.AccountStatsMemRatio' field func SetCacheAccountStatsMemRatio(v float64) { global.SetCacheAccountStatsMemRatio(v) } +// CacheApplicationMemRatioFlag returns the flag name for the 'Cache.ApplicationMemRatio' field +func CacheApplicationMemRatioFlag() string { return "cache-application-mem-ratio" } + // GetCacheApplicationMemRatio safely fetches the Configuration value for state's 'Cache.ApplicationMemRatio' field func (st *ConfigState) GetCacheApplicationMemRatio() (v float64) { st.mutex.RLock() @@ -3047,15 +4922,15 @@ func (st *ConfigState) SetCacheApplicationMemRatio(v float64) { st.reloadToViper() } -// CacheApplicationMemRatioFlag returns the flag name for the 'Cache.ApplicationMemRatio' field -func CacheApplicationMemRatioFlag() string { return "cache-application-mem-ratio" } - // GetCacheApplicationMemRatio safely fetches the value for global configuration 'Cache.ApplicationMemRatio' field func GetCacheApplicationMemRatio() float64 { return global.GetCacheApplicationMemRatio() } // SetCacheApplicationMemRatio safely sets the value for global configuration 'Cache.ApplicationMemRatio' field func SetCacheApplicationMemRatio(v float64) { global.SetCacheApplicationMemRatio(v) } +// CacheBlockMemRatioFlag returns the flag name for the 'Cache.BlockMemRatio' field +func CacheBlockMemRatioFlag() string { return "cache-block-mem-ratio" } + // GetCacheBlockMemRatio safely fetches the Configuration value for state's 'Cache.BlockMemRatio' field func (st *ConfigState) GetCacheBlockMemRatio() (v float64) { st.mutex.RLock() @@ -3072,15 +4947,15 @@ func (st *ConfigState) SetCacheBlockMemRatio(v float64) { st.reloadToViper() } -// CacheBlockMemRatioFlag returns the flag name for the 'Cache.BlockMemRatio' field -func CacheBlockMemRatioFlag() string { return "cache-block-mem-ratio" } - // GetCacheBlockMemRatio safely fetches the value for global configuration 'Cache.BlockMemRatio' field func GetCacheBlockMemRatio() float64 { return global.GetCacheBlockMemRatio() } // SetCacheBlockMemRatio safely sets the value for global configuration 'Cache.BlockMemRatio' field func SetCacheBlockMemRatio(v float64) { global.SetCacheBlockMemRatio(v) } +// CacheBlockIDsMemRatioFlag returns the flag name for the 'Cache.BlockIDsMemRatio' field +func CacheBlockIDsMemRatioFlag() string { return "cache-block-ids-mem-ratio" } + // GetCacheBlockIDsMemRatio safely fetches the Configuration value for state's 'Cache.BlockIDsMemRatio' field func (st *ConfigState) GetCacheBlockIDsMemRatio() (v float64) { st.mutex.RLock() @@ -3097,15 +4972,15 @@ func (st *ConfigState) SetCacheBlockIDsMemRatio(v float64) { st.reloadToViper() } -// CacheBlockIDsMemRatioFlag returns the flag name for the 'Cache.BlockIDsMemRatio' field -func CacheBlockIDsMemRatioFlag() string { return "cache-block-ids-mem-ratio" } - // GetCacheBlockIDsMemRatio safely fetches the value for global configuration 'Cache.BlockIDsMemRatio' field func GetCacheBlockIDsMemRatio() float64 { return global.GetCacheBlockIDsMemRatio() } // SetCacheBlockIDsMemRatio safely sets the value for global configuration 'Cache.BlockIDsMemRatio' field func SetCacheBlockIDsMemRatio(v float64) { global.SetCacheBlockIDsMemRatio(v) } +// CacheBoostOfIDsMemRatioFlag returns the flag name for the 'Cache.BoostOfIDsMemRatio' field +func CacheBoostOfIDsMemRatioFlag() string { return "cache-boost-of-ids-mem-ratio" } + // GetCacheBoostOfIDsMemRatio safely fetches the Configuration value for state's 'Cache.BoostOfIDsMemRatio' field func (st *ConfigState) GetCacheBoostOfIDsMemRatio() (v float64) { st.mutex.RLock() @@ -3122,15 +4997,15 @@ func (st *ConfigState) SetCacheBoostOfIDsMemRatio(v float64) { st.reloadToViper() } -// CacheBoostOfIDsMemRatioFlag returns the flag name for the 'Cache.BoostOfIDsMemRatio' field -func CacheBoostOfIDsMemRatioFlag() string { return "cache-boost-of-ids-mem-ratio" } - // GetCacheBoostOfIDsMemRatio safely fetches the value for global configuration 'Cache.BoostOfIDsMemRatio' field func GetCacheBoostOfIDsMemRatio() float64 { return global.GetCacheBoostOfIDsMemRatio() } // SetCacheBoostOfIDsMemRatio safely sets the value for global configuration 'Cache.BoostOfIDsMemRatio' field func SetCacheBoostOfIDsMemRatio(v float64) { global.SetCacheBoostOfIDsMemRatio(v) } +// CacheClientMemRatioFlag returns the flag name for the 'Cache.ClientMemRatio' field +func CacheClientMemRatioFlag() string { return "cache-client-mem-ratio" } + // GetCacheClientMemRatio safely fetches the Configuration value for state's 'Cache.ClientMemRatio' field func (st *ConfigState) GetCacheClientMemRatio() (v float64) { st.mutex.RLock() @@ -3147,15 +5022,15 @@ func (st *ConfigState) SetCacheClientMemRatio(v float64) { st.reloadToViper() } -// CacheClientMemRatioFlag returns the flag name for the 'Cache.ClientMemRatio' field -func CacheClientMemRatioFlag() string { return "cache-client-mem-ratio" } - // GetCacheClientMemRatio safely fetches the value for global configuration 'Cache.ClientMemRatio' field func GetCacheClientMemRatio() float64 { return global.GetCacheClientMemRatio() } // SetCacheClientMemRatio safely sets the value for global configuration 'Cache.ClientMemRatio' field func SetCacheClientMemRatio(v float64) { global.SetCacheClientMemRatio(v) } +// CacheConversationMemRatioFlag returns the flag name for the 'Cache.ConversationMemRatio' field +func CacheConversationMemRatioFlag() string { return "cache-conversation-mem-ratio" } + // GetCacheConversationMemRatio safely fetches the Configuration value for state's 'Cache.ConversationMemRatio' field func (st *ConfigState) GetCacheConversationMemRatio() (v float64) { st.mutex.RLock() @@ -3172,15 +5047,17 @@ func (st *ConfigState) SetCacheConversationMemRatio(v float64) { st.reloadToViper() } -// CacheConversationMemRatioFlag returns the flag name for the 'Cache.ConversationMemRatio' field -func CacheConversationMemRatioFlag() string { return "cache-conversation-mem-ratio" } - // GetCacheConversationMemRatio safely fetches the value for global configuration 'Cache.ConversationMemRatio' field func GetCacheConversationMemRatio() float64 { return global.GetCacheConversationMemRatio() } // SetCacheConversationMemRatio safely sets the value for global configuration 'Cache.ConversationMemRatio' field func SetCacheConversationMemRatio(v float64) { global.SetCacheConversationMemRatio(v) } +// CacheConversationLastStatusIDsMemRatioFlag returns the flag name for the 'Cache.ConversationLastStatusIDsMemRatio' field +func CacheConversationLastStatusIDsMemRatioFlag() string { + return "cache-conversation-last-status-ids-mem-ratio" +} + // GetCacheConversationLastStatusIDsMemRatio safely fetches the Configuration value for state's 'Cache.ConversationLastStatusIDsMemRatio' field func (st *ConfigState) GetCacheConversationLastStatusIDsMemRatio() (v float64) { st.mutex.RLock() @@ -3197,11 +5074,6 @@ func (st *ConfigState) SetCacheConversationLastStatusIDsMemRatio(v float64) { st.reloadToViper() } -// CacheConversationLastStatusIDsMemRatioFlag returns the flag name for the 'Cache.ConversationLastStatusIDsMemRatio' field -func CacheConversationLastStatusIDsMemRatioFlag() string { - return "cache-conversation-last-status-ids-mem-ratio" -} - // GetCacheConversationLastStatusIDsMemRatio safely fetches the value for global configuration 'Cache.ConversationLastStatusIDsMemRatio' field func GetCacheConversationLastStatusIDsMemRatio() float64 { return global.GetCacheConversationLastStatusIDsMemRatio() @@ -3212,6 +5084,11 @@ func SetCacheConversationLastStatusIDsMemRatio(v float64) { global.SetCacheConversationLastStatusIDsMemRatio(v) } +// CacheDomainPermissionDraftMemRationFlag returns the flag name for the 'Cache.DomainPermissionDraftMemRation' field +func CacheDomainPermissionDraftMemRationFlag() string { + return "cache-domain-permission-draft-mem-ratio" +} + // GetCacheDomainPermissionDraftMemRation safely fetches the Configuration value for state's 'Cache.DomainPermissionDraftMemRation' field func (st *ConfigState) GetCacheDomainPermissionDraftMemRation() (v float64) { st.mutex.RLock() @@ -3228,11 +5105,6 @@ func (st *ConfigState) SetCacheDomainPermissionDraftMemRation(v float64) { st.reloadToViper() } -// CacheDomainPermissionDraftMemRationFlag returns the flag name for the 'Cache.DomainPermissionDraftMemRation' field -func CacheDomainPermissionDraftMemRationFlag() string { - return "cache-domain-permission-draft-mem-ratio" -} - // GetCacheDomainPermissionDraftMemRation safely fetches the value for global configuration 'Cache.DomainPermissionDraftMemRation' field func GetCacheDomainPermissionDraftMemRation() float64 { return global.GetCacheDomainPermissionDraftMemRation() @@ -3243,6 +5115,11 @@ func SetCacheDomainPermissionDraftMemRation(v float64) { global.SetCacheDomainPermissionDraftMemRation(v) } +// CacheDomainPermissionSubscriptionMemRationFlag returns the flag name for the 'Cache.DomainPermissionSubscriptionMemRation' field +func CacheDomainPermissionSubscriptionMemRationFlag() string { + return "cache-domain-permission-subscription-mem-ratio" +} + // GetCacheDomainPermissionSubscriptionMemRation safely fetches the Configuration value for state's 'Cache.DomainPermissionSubscriptionMemRation' field func (st *ConfigState) GetCacheDomainPermissionSubscriptionMemRation() (v float64) { st.mutex.RLock() @@ -3259,11 +5136,6 @@ func (st *ConfigState) SetCacheDomainPermissionSubscriptionMemRation(v float64) st.reloadToViper() } -// CacheDomainPermissionSubscriptionMemRationFlag returns the flag name for the 'Cache.DomainPermissionSubscriptionMemRation' field -func CacheDomainPermissionSubscriptionMemRationFlag() string { - return "cache-domain-permission-subscription-mem-ratio" -} - // GetCacheDomainPermissionSubscriptionMemRation safely fetches the value for global configuration 'Cache.DomainPermissionSubscriptionMemRation' field func GetCacheDomainPermissionSubscriptionMemRation() float64 { return global.GetCacheDomainPermissionSubscriptionMemRation() @@ -3274,6 +5146,9 @@ func SetCacheDomainPermissionSubscriptionMemRation(v float64) { global.SetCacheDomainPermissionSubscriptionMemRation(v) } +// CacheEmojiMemRatioFlag returns the flag name for the 'Cache.EmojiMemRatio' field +func CacheEmojiMemRatioFlag() string { return "cache-emoji-mem-ratio" } + // GetCacheEmojiMemRatio safely fetches the Configuration value for state's 'Cache.EmojiMemRatio' field func (st *ConfigState) GetCacheEmojiMemRatio() (v float64) { st.mutex.RLock() @@ -3290,15 +5165,15 @@ func (st *ConfigState) SetCacheEmojiMemRatio(v float64) { st.reloadToViper() } -// CacheEmojiMemRatioFlag returns the flag name for the 'Cache.EmojiMemRatio' field -func CacheEmojiMemRatioFlag() string { return "cache-emoji-mem-ratio" } - // GetCacheEmojiMemRatio safely fetches the value for global configuration 'Cache.EmojiMemRatio' field func GetCacheEmojiMemRatio() float64 { return global.GetCacheEmojiMemRatio() } // SetCacheEmojiMemRatio safely sets the value for global configuration 'Cache.EmojiMemRatio' field func SetCacheEmojiMemRatio(v float64) { global.SetCacheEmojiMemRatio(v) } +// CacheEmojiCategoryMemRatioFlag returns the flag name for the 'Cache.EmojiCategoryMemRatio' field +func CacheEmojiCategoryMemRatioFlag() string { return "cache-emoji-category-mem-ratio" } + // GetCacheEmojiCategoryMemRatio safely fetches the Configuration value for state's 'Cache.EmojiCategoryMemRatio' field func (st *ConfigState) GetCacheEmojiCategoryMemRatio() (v float64) { st.mutex.RLock() @@ -3315,15 +5190,15 @@ func (st *ConfigState) SetCacheEmojiCategoryMemRatio(v float64) { st.reloadToViper() } -// CacheEmojiCategoryMemRatioFlag returns the flag name for the 'Cache.EmojiCategoryMemRatio' field -func CacheEmojiCategoryMemRatioFlag() string { return "cache-emoji-category-mem-ratio" } - // GetCacheEmojiCategoryMemRatio safely fetches the value for global configuration 'Cache.EmojiCategoryMemRatio' field func GetCacheEmojiCategoryMemRatio() float64 { return global.GetCacheEmojiCategoryMemRatio() } // SetCacheEmojiCategoryMemRatio safely sets the value for global configuration 'Cache.EmojiCategoryMemRatio' field func SetCacheEmojiCategoryMemRatio(v float64) { global.SetCacheEmojiCategoryMemRatio(v) } +// CacheFilterMemRatioFlag returns the flag name for the 'Cache.FilterMemRatio' field +func CacheFilterMemRatioFlag() string { return "cache-filter-mem-ratio" } + // GetCacheFilterMemRatio safely fetches the Configuration value for state's 'Cache.FilterMemRatio' field func (st *ConfigState) GetCacheFilterMemRatio() (v float64) { st.mutex.RLock() @@ -3340,15 +5215,15 @@ func (st *ConfigState) SetCacheFilterMemRatio(v float64) { st.reloadToViper() } -// CacheFilterMemRatioFlag returns the flag name for the 'Cache.FilterMemRatio' field -func CacheFilterMemRatioFlag() string { return "cache-filter-mem-ratio" } - // GetCacheFilterMemRatio safely fetches the value for global configuration 'Cache.FilterMemRatio' field func GetCacheFilterMemRatio() float64 { return global.GetCacheFilterMemRatio() } // SetCacheFilterMemRatio safely sets the value for global configuration 'Cache.FilterMemRatio' field func SetCacheFilterMemRatio(v float64) { global.SetCacheFilterMemRatio(v) } +// CacheFilterKeywordMemRatioFlag returns the flag name for the 'Cache.FilterKeywordMemRatio' field +func CacheFilterKeywordMemRatioFlag() string { return "cache-filter-keyword-mem-ratio" } + // GetCacheFilterKeywordMemRatio safely fetches the Configuration value for state's 'Cache.FilterKeywordMemRatio' field func (st *ConfigState) GetCacheFilterKeywordMemRatio() (v float64) { st.mutex.RLock() @@ -3365,15 +5240,15 @@ func (st *ConfigState) SetCacheFilterKeywordMemRatio(v float64) { st.reloadToViper() } -// CacheFilterKeywordMemRatioFlag returns the flag name for the 'Cache.FilterKeywordMemRatio' field -func CacheFilterKeywordMemRatioFlag() string { return "cache-filter-keyword-mem-ratio" } - // GetCacheFilterKeywordMemRatio safely fetches the value for global configuration 'Cache.FilterKeywordMemRatio' field func GetCacheFilterKeywordMemRatio() float64 { return global.GetCacheFilterKeywordMemRatio() } // SetCacheFilterKeywordMemRatio safely sets the value for global configuration 'Cache.FilterKeywordMemRatio' field func SetCacheFilterKeywordMemRatio(v float64) { global.SetCacheFilterKeywordMemRatio(v) } +// CacheFilterStatusMemRatioFlag returns the flag name for the 'Cache.FilterStatusMemRatio' field +func CacheFilterStatusMemRatioFlag() string { return "cache-filter-status-mem-ratio" } + // GetCacheFilterStatusMemRatio safely fetches the Configuration value for state's 'Cache.FilterStatusMemRatio' field func (st *ConfigState) GetCacheFilterStatusMemRatio() (v float64) { st.mutex.RLock() @@ -3390,15 +5265,15 @@ func (st *ConfigState) SetCacheFilterStatusMemRatio(v float64) { st.reloadToViper() } -// CacheFilterStatusMemRatioFlag returns the flag name for the 'Cache.FilterStatusMemRatio' field -func CacheFilterStatusMemRatioFlag() string { return "cache-filter-status-mem-ratio" } - // GetCacheFilterStatusMemRatio safely fetches the value for global configuration 'Cache.FilterStatusMemRatio' field func GetCacheFilterStatusMemRatio() float64 { return global.GetCacheFilterStatusMemRatio() } // SetCacheFilterStatusMemRatio safely sets the value for global configuration 'Cache.FilterStatusMemRatio' field func SetCacheFilterStatusMemRatio(v float64) { global.SetCacheFilterStatusMemRatio(v) } +// CacheFollowMemRatioFlag returns the flag name for the 'Cache.FollowMemRatio' field +func CacheFollowMemRatioFlag() string { return "cache-follow-mem-ratio" } + // GetCacheFollowMemRatio safely fetches the Configuration value for state's 'Cache.FollowMemRatio' field func (st *ConfigState) GetCacheFollowMemRatio() (v float64) { st.mutex.RLock() @@ -3415,15 +5290,15 @@ func (st *ConfigState) SetCacheFollowMemRatio(v float64) { st.reloadToViper() } -// CacheFollowMemRatioFlag returns the flag name for the 'Cache.FollowMemRatio' field -func CacheFollowMemRatioFlag() string { return "cache-follow-mem-ratio" } - // GetCacheFollowMemRatio safely fetches the value for global configuration 'Cache.FollowMemRatio' field func GetCacheFollowMemRatio() float64 { return global.GetCacheFollowMemRatio() } // SetCacheFollowMemRatio safely sets the value for global configuration 'Cache.FollowMemRatio' field func SetCacheFollowMemRatio(v float64) { global.SetCacheFollowMemRatio(v) } +// CacheFollowIDsMemRatioFlag returns the flag name for the 'Cache.FollowIDsMemRatio' field +func CacheFollowIDsMemRatioFlag() string { return "cache-follow-ids-mem-ratio" } + // GetCacheFollowIDsMemRatio safely fetches the Configuration value for state's 'Cache.FollowIDsMemRatio' field func (st *ConfigState) GetCacheFollowIDsMemRatio() (v float64) { st.mutex.RLock() @@ -3440,15 +5315,15 @@ func (st *ConfigState) SetCacheFollowIDsMemRatio(v float64) { st.reloadToViper() } -// CacheFollowIDsMemRatioFlag returns the flag name for the 'Cache.FollowIDsMemRatio' field -func CacheFollowIDsMemRatioFlag() string { return "cache-follow-ids-mem-ratio" } - // GetCacheFollowIDsMemRatio safely fetches the value for global configuration 'Cache.FollowIDsMemRatio' field func GetCacheFollowIDsMemRatio() float64 { return global.GetCacheFollowIDsMemRatio() } // SetCacheFollowIDsMemRatio safely sets the value for global configuration 'Cache.FollowIDsMemRatio' field func SetCacheFollowIDsMemRatio(v float64) { global.SetCacheFollowIDsMemRatio(v) } +// CacheFollowRequestMemRatioFlag returns the flag name for the 'Cache.FollowRequestMemRatio' field +func CacheFollowRequestMemRatioFlag() string { return "cache-follow-request-mem-ratio" } + // GetCacheFollowRequestMemRatio safely fetches the Configuration value for state's 'Cache.FollowRequestMemRatio' field func (st *ConfigState) GetCacheFollowRequestMemRatio() (v float64) { st.mutex.RLock() @@ -3465,15 +5340,15 @@ func (st *ConfigState) SetCacheFollowRequestMemRatio(v float64) { st.reloadToViper() } -// CacheFollowRequestMemRatioFlag returns the flag name for the 'Cache.FollowRequestMemRatio' field -func CacheFollowRequestMemRatioFlag() string { return "cache-follow-request-mem-ratio" } - // GetCacheFollowRequestMemRatio safely fetches the value for global configuration 'Cache.FollowRequestMemRatio' field func GetCacheFollowRequestMemRatio() float64 { return global.GetCacheFollowRequestMemRatio() } // SetCacheFollowRequestMemRatio safely sets the value for global configuration 'Cache.FollowRequestMemRatio' field func SetCacheFollowRequestMemRatio(v float64) { global.SetCacheFollowRequestMemRatio(v) } +// CacheFollowRequestIDsMemRatioFlag returns the flag name for the 'Cache.FollowRequestIDsMemRatio' field +func CacheFollowRequestIDsMemRatioFlag() string { return "cache-follow-request-ids-mem-ratio" } + // GetCacheFollowRequestIDsMemRatio safely fetches the Configuration value for state's 'Cache.FollowRequestIDsMemRatio' field func (st *ConfigState) GetCacheFollowRequestIDsMemRatio() (v float64) { st.mutex.RLock() @@ -3490,15 +5365,15 @@ func (st *ConfigState) SetCacheFollowRequestIDsMemRatio(v float64) { st.reloadToViper() } -// CacheFollowRequestIDsMemRatioFlag returns the flag name for the 'Cache.FollowRequestIDsMemRatio' field -func CacheFollowRequestIDsMemRatioFlag() string { return "cache-follow-request-ids-mem-ratio" } - // GetCacheFollowRequestIDsMemRatio safely fetches the value for global configuration 'Cache.FollowRequestIDsMemRatio' field func GetCacheFollowRequestIDsMemRatio() float64 { return global.GetCacheFollowRequestIDsMemRatio() } // SetCacheFollowRequestIDsMemRatio safely sets the value for global configuration 'Cache.FollowRequestIDsMemRatio' field func SetCacheFollowRequestIDsMemRatio(v float64) { global.SetCacheFollowRequestIDsMemRatio(v) } +// CacheFollowingTagIDsMemRatioFlag returns the flag name for the 'Cache.FollowingTagIDsMemRatio' field +func CacheFollowingTagIDsMemRatioFlag() string { return "cache-following-tag-ids-mem-ratio" } + // GetCacheFollowingTagIDsMemRatio safely fetches the Configuration value for state's 'Cache.FollowingTagIDsMemRatio' field func (st *ConfigState) GetCacheFollowingTagIDsMemRatio() (v float64) { st.mutex.RLock() @@ -3515,15 +5390,15 @@ func (st *ConfigState) SetCacheFollowingTagIDsMemRatio(v float64) { st.reloadToViper() } -// CacheFollowingTagIDsMemRatioFlag returns the flag name for the 'Cache.FollowingTagIDsMemRatio' field -func CacheFollowingTagIDsMemRatioFlag() string { return "cache-following-tag-ids-mem-ratio" } - // GetCacheFollowingTagIDsMemRatio safely fetches the value for global configuration 'Cache.FollowingTagIDsMemRatio' field func GetCacheFollowingTagIDsMemRatio() float64 { return global.GetCacheFollowingTagIDsMemRatio() } // SetCacheFollowingTagIDsMemRatio safely sets the value for global configuration 'Cache.FollowingTagIDsMemRatio' field func SetCacheFollowingTagIDsMemRatio(v float64) { global.SetCacheFollowingTagIDsMemRatio(v) } +// CacheInReplyToIDsMemRatioFlag returns the flag name for the 'Cache.InReplyToIDsMemRatio' field +func CacheInReplyToIDsMemRatioFlag() string { return "cache-in-reply-to-ids-mem-ratio" } + // GetCacheInReplyToIDsMemRatio safely fetches the Configuration value for state's 'Cache.InReplyToIDsMemRatio' field func (st *ConfigState) GetCacheInReplyToIDsMemRatio() (v float64) { st.mutex.RLock() @@ -3540,15 +5415,15 @@ func (st *ConfigState) SetCacheInReplyToIDsMemRatio(v float64) { st.reloadToViper() } -// CacheInReplyToIDsMemRatioFlag returns the flag name for the 'Cache.InReplyToIDsMemRatio' field -func CacheInReplyToIDsMemRatioFlag() string { return "cache-in-reply-to-ids-mem-ratio" } - // GetCacheInReplyToIDsMemRatio safely fetches the value for global configuration 'Cache.InReplyToIDsMemRatio' field func GetCacheInReplyToIDsMemRatio() float64 { return global.GetCacheInReplyToIDsMemRatio() } // SetCacheInReplyToIDsMemRatio safely sets the value for global configuration 'Cache.InReplyToIDsMemRatio' field func SetCacheInReplyToIDsMemRatio(v float64) { global.SetCacheInReplyToIDsMemRatio(v) } +// CacheInstanceMemRatioFlag returns the flag name for the 'Cache.InstanceMemRatio' field +func CacheInstanceMemRatioFlag() string { return "cache-instance-mem-ratio" } + // GetCacheInstanceMemRatio safely fetches the Configuration value for state's 'Cache.InstanceMemRatio' field func (st *ConfigState) GetCacheInstanceMemRatio() (v float64) { st.mutex.RLock() @@ -3565,15 +5440,15 @@ func (st *ConfigState) SetCacheInstanceMemRatio(v float64) { st.reloadToViper() } -// CacheInstanceMemRatioFlag returns the flag name for the 'Cache.InstanceMemRatio' field -func CacheInstanceMemRatioFlag() string { return "cache-instance-mem-ratio" } - // GetCacheInstanceMemRatio safely fetches the value for global configuration 'Cache.InstanceMemRatio' field func GetCacheInstanceMemRatio() float64 { return global.GetCacheInstanceMemRatio() } // SetCacheInstanceMemRatio safely sets the value for global configuration 'Cache.InstanceMemRatio' field func SetCacheInstanceMemRatio(v float64) { global.SetCacheInstanceMemRatio(v) } +// CacheInteractionRequestMemRatioFlag returns the flag name for the 'Cache.InteractionRequestMemRatio' field +func CacheInteractionRequestMemRatioFlag() string { return "cache-interaction-request-mem-ratio" } + // GetCacheInteractionRequestMemRatio safely fetches the Configuration value for state's 'Cache.InteractionRequestMemRatio' field func (st *ConfigState) GetCacheInteractionRequestMemRatio() (v float64) { st.mutex.RLock() @@ -3590,15 +5465,15 @@ func (st *ConfigState) SetCacheInteractionRequestMemRatio(v float64) { st.reloadToViper() } -// CacheInteractionRequestMemRatioFlag returns the flag name for the 'Cache.InteractionRequestMemRatio' field -func CacheInteractionRequestMemRatioFlag() string { return "cache-interaction-request-mem-ratio" } - // GetCacheInteractionRequestMemRatio safely fetches the value for global configuration 'Cache.InteractionRequestMemRatio' field func GetCacheInteractionRequestMemRatio() float64 { return global.GetCacheInteractionRequestMemRatio() } // SetCacheInteractionRequestMemRatio safely sets the value for global configuration 'Cache.InteractionRequestMemRatio' field func SetCacheInteractionRequestMemRatio(v float64) { global.SetCacheInteractionRequestMemRatio(v) } +// CacheListMemRatioFlag returns the flag name for the 'Cache.ListMemRatio' field +func CacheListMemRatioFlag() string { return "cache-list-mem-ratio" } + // GetCacheListMemRatio safely fetches the Configuration value for state's 'Cache.ListMemRatio' field func (st *ConfigState) GetCacheListMemRatio() (v float64) { st.mutex.RLock() @@ -3615,15 +5490,15 @@ func (st *ConfigState) SetCacheListMemRatio(v float64) { st.reloadToViper() } -// CacheListMemRatioFlag returns the flag name for the 'Cache.ListMemRatio' field -func CacheListMemRatioFlag() string { return "cache-list-mem-ratio" } - // GetCacheListMemRatio safely fetches the value for global configuration 'Cache.ListMemRatio' field func GetCacheListMemRatio() float64 { return global.GetCacheListMemRatio() } // SetCacheListMemRatio safely sets the value for global configuration 'Cache.ListMemRatio' field func SetCacheListMemRatio(v float64) { global.SetCacheListMemRatio(v) } +// CacheListIDsMemRatioFlag returns the flag name for the 'Cache.ListIDsMemRatio' field +func CacheListIDsMemRatioFlag() string { return "cache-list-ids-mem-ratio" } + // GetCacheListIDsMemRatio safely fetches the Configuration value for state's 'Cache.ListIDsMemRatio' field func (st *ConfigState) GetCacheListIDsMemRatio() (v float64) { st.mutex.RLock() @@ -3640,15 +5515,15 @@ func (st *ConfigState) SetCacheListIDsMemRatio(v float64) { st.reloadToViper() } -// CacheListIDsMemRatioFlag returns the flag name for the 'Cache.ListIDsMemRatio' field -func CacheListIDsMemRatioFlag() string { return "cache-list-ids-mem-ratio" } - // GetCacheListIDsMemRatio safely fetches the value for global configuration 'Cache.ListIDsMemRatio' field func GetCacheListIDsMemRatio() float64 { return global.GetCacheListIDsMemRatio() } // SetCacheListIDsMemRatio safely sets the value for global configuration 'Cache.ListIDsMemRatio' field func SetCacheListIDsMemRatio(v float64) { global.SetCacheListIDsMemRatio(v) } +// CacheListedIDsMemRatioFlag returns the flag name for the 'Cache.ListedIDsMemRatio' field +func CacheListedIDsMemRatioFlag() string { return "cache-listed-ids-mem-ratio" } + // GetCacheListedIDsMemRatio safely fetches the Configuration value for state's 'Cache.ListedIDsMemRatio' field func (st *ConfigState) GetCacheListedIDsMemRatio() (v float64) { st.mutex.RLock() @@ -3665,15 +5540,15 @@ func (st *ConfigState) SetCacheListedIDsMemRatio(v float64) { st.reloadToViper() } -// CacheListedIDsMemRatioFlag returns the flag name for the 'Cache.ListedIDsMemRatio' field -func CacheListedIDsMemRatioFlag() string { return "cache-listed-ids-mem-ratio" } - // GetCacheListedIDsMemRatio safely fetches the value for global configuration 'Cache.ListedIDsMemRatio' field func GetCacheListedIDsMemRatio() float64 { return global.GetCacheListedIDsMemRatio() } // SetCacheListedIDsMemRatio safely sets the value for global configuration 'Cache.ListedIDsMemRatio' field func SetCacheListedIDsMemRatio(v float64) { global.SetCacheListedIDsMemRatio(v) } +// CacheMarkerMemRatioFlag returns the flag name for the 'Cache.MarkerMemRatio' field +func CacheMarkerMemRatioFlag() string { return "cache-marker-mem-ratio" } + // GetCacheMarkerMemRatio safely fetches the Configuration value for state's 'Cache.MarkerMemRatio' field func (st *ConfigState) GetCacheMarkerMemRatio() (v float64) { st.mutex.RLock() @@ -3690,15 +5565,15 @@ func (st *ConfigState) SetCacheMarkerMemRatio(v float64) { st.reloadToViper() } -// CacheMarkerMemRatioFlag returns the flag name for the 'Cache.MarkerMemRatio' field -func CacheMarkerMemRatioFlag() string { return "cache-marker-mem-ratio" } - // GetCacheMarkerMemRatio safely fetches the value for global configuration 'Cache.MarkerMemRatio' field func GetCacheMarkerMemRatio() float64 { return global.GetCacheMarkerMemRatio() } // SetCacheMarkerMemRatio safely sets the value for global configuration 'Cache.MarkerMemRatio' field func SetCacheMarkerMemRatio(v float64) { global.SetCacheMarkerMemRatio(v) } +// CacheMediaMemRatioFlag returns the flag name for the 'Cache.MediaMemRatio' field +func CacheMediaMemRatioFlag() string { return "cache-media-mem-ratio" } + // GetCacheMediaMemRatio safely fetches the Configuration value for state's 'Cache.MediaMemRatio' field func (st *ConfigState) GetCacheMediaMemRatio() (v float64) { st.mutex.RLock() @@ -3715,15 +5590,15 @@ func (st *ConfigState) SetCacheMediaMemRatio(v float64) { st.reloadToViper() } -// CacheMediaMemRatioFlag returns the flag name for the 'Cache.MediaMemRatio' field -func CacheMediaMemRatioFlag() string { return "cache-media-mem-ratio" } - // GetCacheMediaMemRatio safely fetches the value for global configuration 'Cache.MediaMemRatio' field func GetCacheMediaMemRatio() float64 { return global.GetCacheMediaMemRatio() } // SetCacheMediaMemRatio safely sets the value for global configuration 'Cache.MediaMemRatio' field func SetCacheMediaMemRatio(v float64) { global.SetCacheMediaMemRatio(v) } +// CacheMentionMemRatioFlag returns the flag name for the 'Cache.MentionMemRatio' field +func CacheMentionMemRatioFlag() string { return "cache-mention-mem-ratio" } + // GetCacheMentionMemRatio safely fetches the Configuration value for state's 'Cache.MentionMemRatio' field func (st *ConfigState) GetCacheMentionMemRatio() (v float64) { st.mutex.RLock() @@ -3740,15 +5615,15 @@ func (st *ConfigState) SetCacheMentionMemRatio(v float64) { st.reloadToViper() } -// CacheMentionMemRatioFlag returns the flag name for the 'Cache.MentionMemRatio' field -func CacheMentionMemRatioFlag() string { return "cache-mention-mem-ratio" } - // GetCacheMentionMemRatio safely fetches the value for global configuration 'Cache.MentionMemRatio' field func GetCacheMentionMemRatio() float64 { return global.GetCacheMentionMemRatio() } // SetCacheMentionMemRatio safely sets the value for global configuration 'Cache.MentionMemRatio' field func SetCacheMentionMemRatio(v float64) { global.SetCacheMentionMemRatio(v) } +// CacheMoveMemRatioFlag returns the flag name for the 'Cache.MoveMemRatio' field +func CacheMoveMemRatioFlag() string { return "cache-move-mem-ratio" } + // GetCacheMoveMemRatio safely fetches the Configuration value for state's 'Cache.MoveMemRatio' field func (st *ConfigState) GetCacheMoveMemRatio() (v float64) { st.mutex.RLock() @@ -3765,15 +5640,15 @@ func (st *ConfigState) SetCacheMoveMemRatio(v float64) { st.reloadToViper() } -// CacheMoveMemRatioFlag returns the flag name for the 'Cache.MoveMemRatio' field -func CacheMoveMemRatioFlag() string { return "cache-move-mem-ratio" } - // GetCacheMoveMemRatio safely fetches the value for global configuration 'Cache.MoveMemRatio' field func GetCacheMoveMemRatio() float64 { return global.GetCacheMoveMemRatio() } // SetCacheMoveMemRatio safely sets the value for global configuration 'Cache.MoveMemRatio' field func SetCacheMoveMemRatio(v float64) { global.SetCacheMoveMemRatio(v) } +// CacheNotificationMemRatioFlag returns the flag name for the 'Cache.NotificationMemRatio' field +func CacheNotificationMemRatioFlag() string { return "cache-notification-mem-ratio" } + // GetCacheNotificationMemRatio safely fetches the Configuration value for state's 'Cache.NotificationMemRatio' field func (st *ConfigState) GetCacheNotificationMemRatio() (v float64) { st.mutex.RLock() @@ -3790,15 +5665,15 @@ func (st *ConfigState) SetCacheNotificationMemRatio(v float64) { st.reloadToViper() } -// CacheNotificationMemRatioFlag returns the flag name for the 'Cache.NotificationMemRatio' field -func CacheNotificationMemRatioFlag() string { return "cache-notification-mem-ratio" } - // GetCacheNotificationMemRatio safely fetches the value for global configuration 'Cache.NotificationMemRatio' field func GetCacheNotificationMemRatio() float64 { return global.GetCacheNotificationMemRatio() } // SetCacheNotificationMemRatio safely sets the value for global configuration 'Cache.NotificationMemRatio' field func SetCacheNotificationMemRatio(v float64) { global.SetCacheNotificationMemRatio(v) } +// CachePollMemRatioFlag returns the flag name for the 'Cache.PollMemRatio' field +func CachePollMemRatioFlag() string { return "cache-poll-mem-ratio" } + // GetCachePollMemRatio safely fetches the Configuration value for state's 'Cache.PollMemRatio' field func (st *ConfigState) GetCachePollMemRatio() (v float64) { st.mutex.RLock() @@ -3815,15 +5690,15 @@ func (st *ConfigState) SetCachePollMemRatio(v float64) { st.reloadToViper() } -// CachePollMemRatioFlag returns the flag name for the 'Cache.PollMemRatio' field -func CachePollMemRatioFlag() string { return "cache-poll-mem-ratio" } - // GetCachePollMemRatio safely fetches the value for global configuration 'Cache.PollMemRatio' field func GetCachePollMemRatio() float64 { return global.GetCachePollMemRatio() } // SetCachePollMemRatio safely sets the value for global configuration 'Cache.PollMemRatio' field func SetCachePollMemRatio(v float64) { global.SetCachePollMemRatio(v) } +// CachePollVoteMemRatioFlag returns the flag name for the 'Cache.PollVoteMemRatio' field +func CachePollVoteMemRatioFlag() string { return "cache-poll-vote-mem-ratio" } + // GetCachePollVoteMemRatio safely fetches the Configuration value for state's 'Cache.PollVoteMemRatio' field func (st *ConfigState) GetCachePollVoteMemRatio() (v float64) { st.mutex.RLock() @@ -3840,15 +5715,15 @@ func (st *ConfigState) SetCachePollVoteMemRatio(v float64) { st.reloadToViper() } -// CachePollVoteMemRatioFlag returns the flag name for the 'Cache.PollVoteMemRatio' field -func CachePollVoteMemRatioFlag() string { return "cache-poll-vote-mem-ratio" } - // GetCachePollVoteMemRatio safely fetches the value for global configuration 'Cache.PollVoteMemRatio' field func GetCachePollVoteMemRatio() float64 { return global.GetCachePollVoteMemRatio() } // SetCachePollVoteMemRatio safely sets the value for global configuration 'Cache.PollVoteMemRatio' field func SetCachePollVoteMemRatio(v float64) { global.SetCachePollVoteMemRatio(v) } +// CachePollVoteIDsMemRatioFlag returns the flag name for the 'Cache.PollVoteIDsMemRatio' field +func CachePollVoteIDsMemRatioFlag() string { return "cache-poll-vote-ids-mem-ratio" } + // GetCachePollVoteIDsMemRatio safely fetches the Configuration value for state's 'Cache.PollVoteIDsMemRatio' field func (st *ConfigState) GetCachePollVoteIDsMemRatio() (v float64) { st.mutex.RLock() @@ -3865,15 +5740,15 @@ func (st *ConfigState) SetCachePollVoteIDsMemRatio(v float64) { st.reloadToViper() } -// CachePollVoteIDsMemRatioFlag returns the flag name for the 'Cache.PollVoteIDsMemRatio' field -func CachePollVoteIDsMemRatioFlag() string { return "cache-poll-vote-ids-mem-ratio" } - // GetCachePollVoteIDsMemRatio safely fetches the value for global configuration 'Cache.PollVoteIDsMemRatio' field func GetCachePollVoteIDsMemRatio() float64 { return global.GetCachePollVoteIDsMemRatio() } // SetCachePollVoteIDsMemRatio safely sets the value for global configuration 'Cache.PollVoteIDsMemRatio' field func SetCachePollVoteIDsMemRatio(v float64) { global.SetCachePollVoteIDsMemRatio(v) } +// CacheReportMemRatioFlag returns the flag name for the 'Cache.ReportMemRatio' field +func CacheReportMemRatioFlag() string { return "cache-report-mem-ratio" } + // GetCacheReportMemRatio safely fetches the Configuration value for state's 'Cache.ReportMemRatio' field func (st *ConfigState) GetCacheReportMemRatio() (v float64) { st.mutex.RLock() @@ -3890,15 +5765,15 @@ func (st *ConfigState) SetCacheReportMemRatio(v float64) { st.reloadToViper() } -// CacheReportMemRatioFlag returns the flag name for the 'Cache.ReportMemRatio' field -func CacheReportMemRatioFlag() string { return "cache-report-mem-ratio" } - // GetCacheReportMemRatio safely fetches the value for global configuration 'Cache.ReportMemRatio' field func GetCacheReportMemRatio() float64 { return global.GetCacheReportMemRatio() } // SetCacheReportMemRatio safely sets the value for global configuration 'Cache.ReportMemRatio' field func SetCacheReportMemRatio(v float64) { global.SetCacheReportMemRatio(v) } +// CacheSinBinStatusMemRatioFlag returns the flag name for the 'Cache.SinBinStatusMemRatio' field +func CacheSinBinStatusMemRatioFlag() string { return "cache-sin-bin-status-mem-ratio" } + // GetCacheSinBinStatusMemRatio safely fetches the Configuration value for state's 'Cache.SinBinStatusMemRatio' field func (st *ConfigState) GetCacheSinBinStatusMemRatio() (v float64) { st.mutex.RLock() @@ -3915,15 +5790,15 @@ func (st *ConfigState) SetCacheSinBinStatusMemRatio(v float64) { st.reloadToViper() } -// CacheSinBinStatusMemRatioFlag returns the flag name for the 'Cache.SinBinStatusMemRatio' field -func CacheSinBinStatusMemRatioFlag() string { return "cache-sin-bin-status-mem-ratio" } - // GetCacheSinBinStatusMemRatio safely fetches the value for global configuration 'Cache.SinBinStatusMemRatio' field func GetCacheSinBinStatusMemRatio() float64 { return global.GetCacheSinBinStatusMemRatio() } // SetCacheSinBinStatusMemRatio safely sets the value for global configuration 'Cache.SinBinStatusMemRatio' field func SetCacheSinBinStatusMemRatio(v float64) { global.SetCacheSinBinStatusMemRatio(v) } +// CacheStatusMemRatioFlag returns the flag name for the 'Cache.StatusMemRatio' field +func CacheStatusMemRatioFlag() string { return "cache-status-mem-ratio" } + // GetCacheStatusMemRatio safely fetches the Configuration value for state's 'Cache.StatusMemRatio' field func (st *ConfigState) GetCacheStatusMemRatio() (v float64) { st.mutex.RLock() @@ -3940,15 +5815,15 @@ func (st *ConfigState) SetCacheStatusMemRatio(v float64) { st.reloadToViper() } -// CacheStatusMemRatioFlag returns the flag name for the 'Cache.StatusMemRatio' field -func CacheStatusMemRatioFlag() string { return "cache-status-mem-ratio" } - // GetCacheStatusMemRatio safely fetches the value for global configuration 'Cache.StatusMemRatio' field func GetCacheStatusMemRatio() float64 { return global.GetCacheStatusMemRatio() } // SetCacheStatusMemRatio safely sets the value for global configuration 'Cache.StatusMemRatio' field func SetCacheStatusMemRatio(v float64) { global.SetCacheStatusMemRatio(v) } +// CacheStatusBookmarkMemRatioFlag returns the flag name for the 'Cache.StatusBookmarkMemRatio' field +func CacheStatusBookmarkMemRatioFlag() string { return "cache-status-bookmark-mem-ratio" } + // GetCacheStatusBookmarkMemRatio safely fetches the Configuration value for state's 'Cache.StatusBookmarkMemRatio' field func (st *ConfigState) GetCacheStatusBookmarkMemRatio() (v float64) { st.mutex.RLock() @@ -3965,15 +5840,15 @@ func (st *ConfigState) SetCacheStatusBookmarkMemRatio(v float64) { st.reloadToViper() } -// CacheStatusBookmarkMemRatioFlag returns the flag name for the 'Cache.StatusBookmarkMemRatio' field -func CacheStatusBookmarkMemRatioFlag() string { return "cache-status-bookmark-mem-ratio" } - // GetCacheStatusBookmarkMemRatio safely fetches the value for global configuration 'Cache.StatusBookmarkMemRatio' field func GetCacheStatusBookmarkMemRatio() float64 { return global.GetCacheStatusBookmarkMemRatio() } // SetCacheStatusBookmarkMemRatio safely sets the value for global configuration 'Cache.StatusBookmarkMemRatio' field func SetCacheStatusBookmarkMemRatio(v float64) { global.SetCacheStatusBookmarkMemRatio(v) } +// CacheStatusBookmarkIDsMemRatioFlag returns the flag name for the 'Cache.StatusBookmarkIDsMemRatio' field +func CacheStatusBookmarkIDsMemRatioFlag() string { return "cache-status-bookmark-ids-mem-ratio" } + // GetCacheStatusBookmarkIDsMemRatio safely fetches the Configuration value for state's 'Cache.StatusBookmarkIDsMemRatio' field func (st *ConfigState) GetCacheStatusBookmarkIDsMemRatio() (v float64) { st.mutex.RLock() @@ -3990,15 +5865,15 @@ func (st *ConfigState) SetCacheStatusBookmarkIDsMemRatio(v float64) { st.reloadToViper() } -// CacheStatusBookmarkIDsMemRatioFlag returns the flag name for the 'Cache.StatusBookmarkIDsMemRatio' field -func CacheStatusBookmarkIDsMemRatioFlag() string { return "cache-status-bookmark-ids-mem-ratio" } - // GetCacheStatusBookmarkIDsMemRatio safely fetches the value for global configuration 'Cache.StatusBookmarkIDsMemRatio' field func GetCacheStatusBookmarkIDsMemRatio() float64 { return global.GetCacheStatusBookmarkIDsMemRatio() } // SetCacheStatusBookmarkIDsMemRatio safely sets the value for global configuration 'Cache.StatusBookmarkIDsMemRatio' field func SetCacheStatusBookmarkIDsMemRatio(v float64) { global.SetCacheStatusBookmarkIDsMemRatio(v) } +// CacheStatusEditMemRatioFlag returns the flag name for the 'Cache.StatusEditMemRatio' field +func CacheStatusEditMemRatioFlag() string { return "cache-status-edit-mem-ratio" } + // GetCacheStatusEditMemRatio safely fetches the Configuration value for state's 'Cache.StatusEditMemRatio' field func (st *ConfigState) GetCacheStatusEditMemRatio() (v float64) { st.mutex.RLock() @@ -4015,15 +5890,15 @@ func (st *ConfigState) SetCacheStatusEditMemRatio(v float64) { st.reloadToViper() } -// CacheStatusEditMemRatioFlag returns the flag name for the 'Cache.StatusEditMemRatio' field -func CacheStatusEditMemRatioFlag() string { return "cache-status-edit-mem-ratio" } - // GetCacheStatusEditMemRatio safely fetches the value for global configuration 'Cache.StatusEditMemRatio' field func GetCacheStatusEditMemRatio() float64 { return global.GetCacheStatusEditMemRatio() } // SetCacheStatusEditMemRatio safely sets the value for global configuration 'Cache.StatusEditMemRatio' field func SetCacheStatusEditMemRatio(v float64) { global.SetCacheStatusEditMemRatio(v) } +// CacheStatusFaveMemRatioFlag returns the flag name for the 'Cache.StatusFaveMemRatio' field +func CacheStatusFaveMemRatioFlag() string { return "cache-status-fave-mem-ratio" } + // GetCacheStatusFaveMemRatio safely fetches the Configuration value for state's 'Cache.StatusFaveMemRatio' field func (st *ConfigState) GetCacheStatusFaveMemRatio() (v float64) { st.mutex.RLock() @@ -4040,15 +5915,15 @@ func (st *ConfigState) SetCacheStatusFaveMemRatio(v float64) { st.reloadToViper() } -// CacheStatusFaveMemRatioFlag returns the flag name for the 'Cache.StatusFaveMemRatio' field -func CacheStatusFaveMemRatioFlag() string { return "cache-status-fave-mem-ratio" } - // GetCacheStatusFaveMemRatio safely fetches the value for global configuration 'Cache.StatusFaveMemRatio' field func GetCacheStatusFaveMemRatio() float64 { return global.GetCacheStatusFaveMemRatio() } // SetCacheStatusFaveMemRatio safely sets the value for global configuration 'Cache.StatusFaveMemRatio' field func SetCacheStatusFaveMemRatio(v float64) { global.SetCacheStatusFaveMemRatio(v) } +// CacheStatusFaveIDsMemRatioFlag returns the flag name for the 'Cache.StatusFaveIDsMemRatio' field +func CacheStatusFaveIDsMemRatioFlag() string { return "cache-status-fave-ids-mem-ratio" } + // GetCacheStatusFaveIDsMemRatio safely fetches the Configuration value for state's 'Cache.StatusFaveIDsMemRatio' field func (st *ConfigState) GetCacheStatusFaveIDsMemRatio() (v float64) { st.mutex.RLock() @@ -4065,15 +5940,15 @@ func (st *ConfigState) SetCacheStatusFaveIDsMemRatio(v float64) { st.reloadToViper() } -// CacheStatusFaveIDsMemRatioFlag returns the flag name for the 'Cache.StatusFaveIDsMemRatio' field -func CacheStatusFaveIDsMemRatioFlag() string { return "cache-status-fave-ids-mem-ratio" } - // GetCacheStatusFaveIDsMemRatio safely fetches the value for global configuration 'Cache.StatusFaveIDsMemRatio' field func GetCacheStatusFaveIDsMemRatio() float64 { return global.GetCacheStatusFaveIDsMemRatio() } // SetCacheStatusFaveIDsMemRatio safely sets the value for global configuration 'Cache.StatusFaveIDsMemRatio' field func SetCacheStatusFaveIDsMemRatio(v float64) { global.SetCacheStatusFaveIDsMemRatio(v) } +// CacheTagMemRatioFlag returns the flag name for the 'Cache.TagMemRatio' field +func CacheTagMemRatioFlag() string { return "cache-tag-mem-ratio" } + // GetCacheTagMemRatio safely fetches the Configuration value for state's 'Cache.TagMemRatio' field func (st *ConfigState) GetCacheTagMemRatio() (v float64) { st.mutex.RLock() @@ -4090,15 +5965,15 @@ func (st *ConfigState) SetCacheTagMemRatio(v float64) { st.reloadToViper() } -// CacheTagMemRatioFlag returns the flag name for the 'Cache.TagMemRatio' field -func CacheTagMemRatioFlag() string { return "cache-tag-mem-ratio" } - // GetCacheTagMemRatio safely fetches the value for global configuration 'Cache.TagMemRatio' field func GetCacheTagMemRatio() float64 { return global.GetCacheTagMemRatio() } // SetCacheTagMemRatio safely sets the value for global configuration 'Cache.TagMemRatio' field func SetCacheTagMemRatio(v float64) { global.SetCacheTagMemRatio(v) } +// CacheThreadMuteMemRatioFlag returns the flag name for the 'Cache.ThreadMuteMemRatio' field +func CacheThreadMuteMemRatioFlag() string { return "cache-thread-mute-mem-ratio" } + // GetCacheThreadMuteMemRatio safely fetches the Configuration value for state's 'Cache.ThreadMuteMemRatio' field func (st *ConfigState) GetCacheThreadMuteMemRatio() (v float64) { st.mutex.RLock() @@ -4115,15 +5990,15 @@ func (st *ConfigState) SetCacheThreadMuteMemRatio(v float64) { st.reloadToViper() } -// CacheThreadMuteMemRatioFlag returns the flag name for the 'Cache.ThreadMuteMemRatio' field -func CacheThreadMuteMemRatioFlag() string { return "cache-thread-mute-mem-ratio" } - // GetCacheThreadMuteMemRatio safely fetches the value for global configuration 'Cache.ThreadMuteMemRatio' field func GetCacheThreadMuteMemRatio() float64 { return global.GetCacheThreadMuteMemRatio() } // SetCacheThreadMuteMemRatio safely sets the value for global configuration 'Cache.ThreadMuteMemRatio' field func SetCacheThreadMuteMemRatio(v float64) { global.SetCacheThreadMuteMemRatio(v) } +// CacheTokenMemRatioFlag returns the flag name for the 'Cache.TokenMemRatio' field +func CacheTokenMemRatioFlag() string { return "cache-token-mem-ratio" } + // GetCacheTokenMemRatio safely fetches the Configuration value for state's 'Cache.TokenMemRatio' field func (st *ConfigState) GetCacheTokenMemRatio() (v float64) { st.mutex.RLock() @@ -4140,15 +6015,15 @@ func (st *ConfigState) SetCacheTokenMemRatio(v float64) { st.reloadToViper() } -// CacheTokenMemRatioFlag returns the flag name for the 'Cache.TokenMemRatio' field -func CacheTokenMemRatioFlag() string { return "cache-token-mem-ratio" } - // GetCacheTokenMemRatio safely fetches the value for global configuration 'Cache.TokenMemRatio' field func GetCacheTokenMemRatio() float64 { return global.GetCacheTokenMemRatio() } // SetCacheTokenMemRatio safely sets the value for global configuration 'Cache.TokenMemRatio' field func SetCacheTokenMemRatio(v float64) { global.SetCacheTokenMemRatio(v) } +// CacheTombstoneMemRatioFlag returns the flag name for the 'Cache.TombstoneMemRatio' field +func CacheTombstoneMemRatioFlag() string { return "cache-tombstone-mem-ratio" } + // GetCacheTombstoneMemRatio safely fetches the Configuration value for state's 'Cache.TombstoneMemRatio' field func (st *ConfigState) GetCacheTombstoneMemRatio() (v float64) { st.mutex.RLock() @@ -4165,15 +6040,15 @@ func (st *ConfigState) SetCacheTombstoneMemRatio(v float64) { st.reloadToViper() } -// CacheTombstoneMemRatioFlag returns the flag name for the 'Cache.TombstoneMemRatio' field -func CacheTombstoneMemRatioFlag() string { return "cache-tombstone-mem-ratio" } - // GetCacheTombstoneMemRatio safely fetches the value for global configuration 'Cache.TombstoneMemRatio' field func GetCacheTombstoneMemRatio() float64 { return global.GetCacheTombstoneMemRatio() } // SetCacheTombstoneMemRatio safely sets the value for global configuration 'Cache.TombstoneMemRatio' field func SetCacheTombstoneMemRatio(v float64) { global.SetCacheTombstoneMemRatio(v) } +// CacheUserMemRatioFlag returns the flag name for the 'Cache.UserMemRatio' field +func CacheUserMemRatioFlag() string { return "cache-user-mem-ratio" } + // GetCacheUserMemRatio safely fetches the Configuration value for state's 'Cache.UserMemRatio' field func (st *ConfigState) GetCacheUserMemRatio() (v float64) { st.mutex.RLock() @@ -4190,15 +6065,15 @@ func (st *ConfigState) SetCacheUserMemRatio(v float64) { st.reloadToViper() } -// CacheUserMemRatioFlag returns the flag name for the 'Cache.UserMemRatio' field -func CacheUserMemRatioFlag() string { return "cache-user-mem-ratio" } - // GetCacheUserMemRatio safely fetches the value for global configuration 'Cache.UserMemRatio' field func GetCacheUserMemRatio() float64 { return global.GetCacheUserMemRatio() } // SetCacheUserMemRatio safely sets the value for global configuration 'Cache.UserMemRatio' field func SetCacheUserMemRatio(v float64) { global.SetCacheUserMemRatio(v) } +// CacheUserMuteMemRatioFlag returns the flag name for the 'Cache.UserMuteMemRatio' field +func CacheUserMuteMemRatioFlag() string { return "cache-user-mute-mem-ratio" } + // GetCacheUserMuteMemRatio safely fetches the Configuration value for state's 'Cache.UserMuteMemRatio' field func (st *ConfigState) GetCacheUserMuteMemRatio() (v float64) { st.mutex.RLock() @@ -4215,15 +6090,15 @@ func (st *ConfigState) SetCacheUserMuteMemRatio(v float64) { st.reloadToViper() } -// CacheUserMuteMemRatioFlag returns the flag name for the 'Cache.UserMuteMemRatio' field -func CacheUserMuteMemRatioFlag() string { return "cache-user-mute-mem-ratio" } - // GetCacheUserMuteMemRatio safely fetches the value for global configuration 'Cache.UserMuteMemRatio' field func GetCacheUserMuteMemRatio() float64 { return global.GetCacheUserMuteMemRatio() } // SetCacheUserMuteMemRatio safely sets the value for global configuration 'Cache.UserMuteMemRatio' field func SetCacheUserMuteMemRatio(v float64) { global.SetCacheUserMuteMemRatio(v) } +// CacheUserMuteIDsMemRatioFlag returns the flag name for the 'Cache.UserMuteIDsMemRatio' field +func CacheUserMuteIDsMemRatioFlag() string { return "cache-user-mute-ids-mem-ratio" } + // GetCacheUserMuteIDsMemRatio safely fetches the Configuration value for state's 'Cache.UserMuteIDsMemRatio' field func (st *ConfigState) GetCacheUserMuteIDsMemRatio() (v float64) { st.mutex.RLock() @@ -4240,15 +6115,15 @@ func (st *ConfigState) SetCacheUserMuteIDsMemRatio(v float64) { st.reloadToViper() } -// CacheUserMuteIDsMemRatioFlag returns the flag name for the 'Cache.UserMuteIDsMemRatio' field -func CacheUserMuteIDsMemRatioFlag() string { return "cache-user-mute-ids-mem-ratio" } - // GetCacheUserMuteIDsMemRatio safely fetches the value for global configuration 'Cache.UserMuteIDsMemRatio' field func GetCacheUserMuteIDsMemRatio() float64 { return global.GetCacheUserMuteIDsMemRatio() } // SetCacheUserMuteIDsMemRatio safely sets the value for global configuration 'Cache.UserMuteIDsMemRatio' field func SetCacheUserMuteIDsMemRatio(v float64) { global.SetCacheUserMuteIDsMemRatio(v) } +// CacheWebfingerMemRatioFlag returns the flag name for the 'Cache.WebfingerMemRatio' field +func CacheWebfingerMemRatioFlag() string { return "cache-webfinger-mem-ratio" } + // GetCacheWebfingerMemRatio safely fetches the Configuration value for state's 'Cache.WebfingerMemRatio' field func (st *ConfigState) GetCacheWebfingerMemRatio() (v float64) { st.mutex.RLock() @@ -4265,15 +6140,15 @@ func (st *ConfigState) SetCacheWebfingerMemRatio(v float64) { st.reloadToViper() } -// CacheWebfingerMemRatioFlag returns the flag name for the 'Cache.WebfingerMemRatio' field -func CacheWebfingerMemRatioFlag() string { return "cache-webfinger-mem-ratio" } - // GetCacheWebfingerMemRatio safely fetches the value for global configuration 'Cache.WebfingerMemRatio' field func GetCacheWebfingerMemRatio() float64 { return global.GetCacheWebfingerMemRatio() } // SetCacheWebfingerMemRatio safely sets the value for global configuration 'Cache.WebfingerMemRatio' field func SetCacheWebfingerMemRatio(v float64) { global.SetCacheWebfingerMemRatio(v) } +// CacheWebPushSubscriptionMemRatioFlag returns the flag name for the 'Cache.WebPushSubscriptionMemRatio' field +func CacheWebPushSubscriptionMemRatioFlag() string { return "cache-web-push-subscription-mem-ratio" } + // GetCacheWebPushSubscriptionMemRatio safely fetches the Configuration value for state's 'Cache.WebPushSubscriptionMemRatio' field func (st *ConfigState) GetCacheWebPushSubscriptionMemRatio() (v float64) { st.mutex.RLock() @@ -4290,9 +6165,6 @@ func (st *ConfigState) SetCacheWebPushSubscriptionMemRatio(v float64) { st.reloadToViper() } -// CacheWebPushSubscriptionMemRatioFlag returns the flag name for the 'Cache.WebPushSubscriptionMemRatio' field -func CacheWebPushSubscriptionMemRatioFlag() string { return "cache-web-push-subscription-mem-ratio" } - // GetCacheWebPushSubscriptionMemRatio safely fetches the value for global configuration 'Cache.WebPushSubscriptionMemRatio' field func GetCacheWebPushSubscriptionMemRatio() float64 { return global.GetCacheWebPushSubscriptionMemRatio() @@ -4301,6 +6173,11 @@ func GetCacheWebPushSubscriptionMemRatio() float64 { // SetCacheWebPushSubscriptionMemRatio safely sets the value for global configuration 'Cache.WebPushSubscriptionMemRatio' field func SetCacheWebPushSubscriptionMemRatio(v float64) { global.SetCacheWebPushSubscriptionMemRatio(v) } +// CacheWebPushSubscriptionIDsMemRatioFlag returns the flag name for the 'Cache.WebPushSubscriptionIDsMemRatio' field +func CacheWebPushSubscriptionIDsMemRatioFlag() string { + return "cache-web-push-subscription-ids-mem-ratio" +} + // GetCacheWebPushSubscriptionIDsMemRatio safely fetches the Configuration value for state's 'Cache.WebPushSubscriptionIDsMemRatio' field func (st *ConfigState) GetCacheWebPushSubscriptionIDsMemRatio() (v float64) { st.mutex.RLock() @@ -4317,11 +6194,6 @@ func (st *ConfigState) SetCacheWebPushSubscriptionIDsMemRatio(v float64) { st.reloadToViper() } -// CacheWebPushSubscriptionIDsMemRatioFlag returns the flag name for the 'Cache.WebPushSubscriptionIDsMemRatio' field -func CacheWebPushSubscriptionIDsMemRatioFlag() string { - return "cache-web-push-subscription-ids-mem-ratio" -} - // GetCacheWebPushSubscriptionIDsMemRatio safely fetches the value for global configuration 'Cache.WebPushSubscriptionIDsMemRatio' field func GetCacheWebPushSubscriptionIDsMemRatio() float64 { return global.GetCacheWebPushSubscriptionIDsMemRatio() @@ -4332,6 +6204,9 @@ func SetCacheWebPushSubscriptionIDsMemRatio(v float64) { global.SetCacheWebPushSubscriptionIDsMemRatio(v) } +// CacheVisibilityMemRatioFlag returns the flag name for the 'Cache.VisibilityMemRatio' field +func CacheVisibilityMemRatioFlag() string { return "cache-visibility-mem-ratio" } + // GetCacheVisibilityMemRatio safely fetches the Configuration value for state's 'Cache.VisibilityMemRatio' field func (st *ConfigState) GetCacheVisibilityMemRatio() (v float64) { st.mutex.RLock() @@ -4348,15 +6223,15 @@ func (st *ConfigState) SetCacheVisibilityMemRatio(v float64) { st.reloadToViper() } -// CacheVisibilityMemRatioFlag returns the flag name for the 'Cache.VisibilityMemRatio' field -func CacheVisibilityMemRatioFlag() string { return "cache-visibility-mem-ratio" } - // GetCacheVisibilityMemRatio safely fetches the value for global configuration 'Cache.VisibilityMemRatio' field func GetCacheVisibilityMemRatio() float64 { return global.GetCacheVisibilityMemRatio() } // SetCacheVisibilityMemRatio safely sets the value for global configuration 'Cache.VisibilityMemRatio' field func SetCacheVisibilityMemRatio(v float64) { global.SetCacheVisibilityMemRatio(v) } +// AdminAccountUsernameFlag returns the flag name for the 'AdminAccountUsername' field +func AdminAccountUsernameFlag() string { return "username" } + // GetAdminAccountUsername safely fetches the Configuration value for state's 'AdminAccountUsername' field func (st *ConfigState) GetAdminAccountUsername() (v string) { st.mutex.RLock() @@ -4373,15 +6248,15 @@ func (st *ConfigState) SetAdminAccountUsername(v string) { st.reloadToViper() } -// AdminAccountUsernameFlag returns the flag name for the 'AdminAccountUsername' field -func AdminAccountUsernameFlag() string { return "username" } - // GetAdminAccountUsername safely fetches the value for global configuration 'AdminAccountUsername' field func GetAdminAccountUsername() string { return global.GetAdminAccountUsername() } // SetAdminAccountUsername safely sets the value for global configuration 'AdminAccountUsername' field func SetAdminAccountUsername(v string) { global.SetAdminAccountUsername(v) } +// AdminAccountEmailFlag returns the flag name for the 'AdminAccountEmail' field +func AdminAccountEmailFlag() string { return "email" } + // GetAdminAccountEmail safely fetches the Configuration value for state's 'AdminAccountEmail' field func (st *ConfigState) GetAdminAccountEmail() (v string) { st.mutex.RLock() @@ -4398,15 +6273,15 @@ func (st *ConfigState) SetAdminAccountEmail(v string) { st.reloadToViper() } -// AdminAccountEmailFlag returns the flag name for the 'AdminAccountEmail' field -func AdminAccountEmailFlag() string { return "email" } - // GetAdminAccountEmail safely fetches the value for global configuration 'AdminAccountEmail' field func GetAdminAccountEmail() string { return global.GetAdminAccountEmail() } // SetAdminAccountEmail safely sets the value for global configuration 'AdminAccountEmail' field func SetAdminAccountEmail(v string) { global.SetAdminAccountEmail(v) } +// AdminAccountPasswordFlag returns the flag name for the 'AdminAccountPassword' field +func AdminAccountPasswordFlag() string { return "password" } + // GetAdminAccountPassword safely fetches the Configuration value for state's 'AdminAccountPassword' field func (st *ConfigState) GetAdminAccountPassword() (v string) { st.mutex.RLock() @@ -4423,15 +6298,15 @@ func (st *ConfigState) SetAdminAccountPassword(v string) { st.reloadToViper() } -// AdminAccountPasswordFlag returns the flag name for the 'AdminAccountPassword' field -func AdminAccountPasswordFlag() string { return "password" } - // GetAdminAccountPassword safely fetches the value for global configuration 'AdminAccountPassword' field func GetAdminAccountPassword() string { return global.GetAdminAccountPassword() } // SetAdminAccountPassword safely sets the value for global configuration 'AdminAccountPassword' field func SetAdminAccountPassword(v string) { global.SetAdminAccountPassword(v) } +// AdminTransPathFlag returns the flag name for the 'AdminTransPath' field +func AdminTransPathFlag() string { return "path" } + // GetAdminTransPath safely fetches the Configuration value for state's 'AdminTransPath' field func (st *ConfigState) GetAdminTransPath() (v string) { st.mutex.RLock() @@ -4448,15 +6323,15 @@ func (st *ConfigState) SetAdminTransPath(v string) { st.reloadToViper() } -// AdminTransPathFlag returns the flag name for the 'AdminTransPath' field -func AdminTransPathFlag() string { return "path" } - // GetAdminTransPath safely fetches the value for global configuration 'AdminTransPath' field func GetAdminTransPath() string { return global.GetAdminTransPath() } // SetAdminTransPath safely sets the value for global configuration 'AdminTransPath' field func SetAdminTransPath(v string) { global.SetAdminTransPath(v) } +// AdminMediaPruneDryRunFlag returns the flag name for the 'AdminMediaPruneDryRun' field +func AdminMediaPruneDryRunFlag() string { return "dry-run" } + // GetAdminMediaPruneDryRun safely fetches the Configuration value for state's 'AdminMediaPruneDryRun' field func (st *ConfigState) GetAdminMediaPruneDryRun() (v bool) { st.mutex.RLock() @@ -4473,15 +6348,15 @@ func (st *ConfigState) SetAdminMediaPruneDryRun(v bool) { st.reloadToViper() } -// AdminMediaPruneDryRunFlag returns the flag name for the 'AdminMediaPruneDryRun' field -func AdminMediaPruneDryRunFlag() string { return "dry-run" } - // GetAdminMediaPruneDryRun safely fetches the value for global configuration 'AdminMediaPruneDryRun' field func GetAdminMediaPruneDryRun() bool { return global.GetAdminMediaPruneDryRun() } // SetAdminMediaPruneDryRun safely sets the value for global configuration 'AdminMediaPruneDryRun' field func SetAdminMediaPruneDryRun(v bool) { global.SetAdminMediaPruneDryRun(v) } +// AdminMediaListLocalOnlyFlag returns the flag name for the 'AdminMediaListLocalOnly' field +func AdminMediaListLocalOnlyFlag() string { return "local-only" } + // GetAdminMediaListLocalOnly safely fetches the Configuration value for state's 'AdminMediaListLocalOnly' field func (st *ConfigState) GetAdminMediaListLocalOnly() (v bool) { st.mutex.RLock() @@ -4498,15 +6373,15 @@ func (st *ConfigState) SetAdminMediaListLocalOnly(v bool) { st.reloadToViper() } -// AdminMediaListLocalOnlyFlag returns the flag name for the 'AdminMediaListLocalOnly' field -func AdminMediaListLocalOnlyFlag() string { return "local-only" } - // GetAdminMediaListLocalOnly safely fetches the value for global configuration 'AdminMediaListLocalOnly' field func GetAdminMediaListLocalOnly() bool { return global.GetAdminMediaListLocalOnly() } // SetAdminMediaListLocalOnly safely sets the value for global configuration 'AdminMediaListLocalOnly' field func SetAdminMediaListLocalOnly(v bool) { global.SetAdminMediaListLocalOnly(v) } +// AdminMediaListRemoteOnlyFlag returns the flag name for the 'AdminMediaListRemoteOnly' field +func AdminMediaListRemoteOnlyFlag() string { return "remote-only" } + // GetAdminMediaListRemoteOnly safely fetches the Configuration value for state's 'AdminMediaListRemoteOnly' field func (st *ConfigState) GetAdminMediaListRemoteOnly() (v bool) { st.mutex.RLock() @@ -4523,36 +6398,789 @@ func (st *ConfigState) SetAdminMediaListRemoteOnly(v bool) { st.reloadToViper() } -// AdminMediaListRemoteOnlyFlag returns the flag name for the 'AdminMediaListRemoteOnly' field -func AdminMediaListRemoteOnlyFlag() string { return "remote-only" } - // GetAdminMediaListRemoteOnly safely fetches the value for global configuration 'AdminMediaListRemoteOnly' field func GetAdminMediaListRemoteOnly() bool { return global.GetAdminMediaListRemoteOnly() } // SetAdminMediaListRemoteOnly safely sets the value for global configuration 'AdminMediaListRemoteOnly' field func SetAdminMediaListRemoteOnly(v bool) { global.SetAdminMediaListRemoteOnly(v) } -// GetRequestIDHeader safely fetches the Configuration value for state's 'RequestIDHeader' field -func (st *ConfigState) GetRequestIDHeader() (v string) { - st.mutex.RLock() - v = st.config.RequestIDHeader - st.mutex.RUnlock() - return -} - -// SetRequestIDHeader safely sets the Configuration value for state's 'RequestIDHeader' field -func (st *ConfigState) SetRequestIDHeader(v string) { - st.mutex.Lock() - defer st.mutex.Unlock() - st.config.RequestIDHeader = v - st.reloadToViper() +func flattenConfigMap(cfgmap map[string]any) { + nestedKeys := make(map[string]struct{}) + for _, key := range [][]string{ + {"advanced", "cookies-samesite"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["advanced-cookies-samesite"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"advanced", "sender-multiplier"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["advanced-sender-multiplier"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"advanced", "csp-extra-uris"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["advanced-csp-extra-uris"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"advanced", "header-filter-mode"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["advanced-header-filter-mode"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"advanced", "scraper-deterrence"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["advanced-scraper-deterrence"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"advanced-rate-limit", "requests"}, + {"advanced", "rate-limit", "requests"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["advanced-rate-limit-requests"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"advanced-rate-limit", "exceptions"}, + {"advanced", "rate-limit", "exceptions"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["advanced-rate-limit-exceptions"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"advanced-throttling", "multiplier"}, + {"advanced", "throttling", "multiplier"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["advanced-throttling-multiplier"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"advanced-throttling", "retry-after"}, + {"advanced", "throttling", "retry-after"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["advanced-throttling-retry-after"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"http-client", "allow-ips"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["http-client-allow-ips"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"http-client", "block-ips"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["http-client-block-ips"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"http-client", "timeout"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["http-client-timeout"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"http-client", "tls-insecure-skip-verify"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["http-client-tls-insecure-skip-verify"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "memory-target"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-memory-target"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "account-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-account-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "account-note-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-account-note-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "account-settings-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-account-settings-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "account-stats-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-account-stats-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "application-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-application-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "block-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-block-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "block-ids-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-block-ids-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "boost-of-ids-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-boost-of-ids-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "client-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-client-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "conversation-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-conversation-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "conversation-last-status-ids-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-conversation-last-status-ids-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "domain-permission-draft-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-domain-permission-draft-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "domain-permission-subscription-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-domain-permission-subscription-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "emoji-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-emoji-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "emoji-category-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-emoji-category-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "filter-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-filter-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "filter-keyword-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-filter-keyword-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "filter-status-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-filter-status-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "follow-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-follow-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "follow-ids-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-follow-ids-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "follow-request-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-follow-request-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "follow-request-ids-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-follow-request-ids-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "following-tag-ids-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-following-tag-ids-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "in-reply-to-ids-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-in-reply-to-ids-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "instance-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-instance-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "interaction-request-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-interaction-request-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "list-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-list-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "list-ids-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-list-ids-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "listed-ids-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-listed-ids-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "marker-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-marker-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "media-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-media-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "mention-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-mention-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "move-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-move-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "notification-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-notification-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "poll-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-poll-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "poll-vote-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-poll-vote-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "poll-vote-ids-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-poll-vote-ids-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "report-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-report-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "sin-bin-status-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-sin-bin-status-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "status-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-status-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "status-bookmark-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-status-bookmark-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "status-bookmark-ids-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-status-bookmark-ids-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "status-edit-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-status-edit-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "status-fave-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-status-fave-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "status-fave-ids-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-status-fave-ids-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "tag-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-tag-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "thread-mute-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-thread-mute-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "token-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-token-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "tombstone-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-tombstone-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "user-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-user-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "user-mute-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-user-mute-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "user-mute-ids-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-user-mute-ids-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "webfinger-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-webfinger-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "web-push-subscription-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-web-push-subscription-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "web-push-subscription-ids-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-web-push-subscription-ids-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for _, key := range [][]string{ + {"cache", "visibility-mem-ratio"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["cache-visibility-mem-ratio"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + + for key := range nestedKeys { + delete(cfgmap, key) + } } - -// RequestIDHeaderFlag returns the flag name for the 'RequestIDHeader' field -func RequestIDHeaderFlag() string { return "request-id-header" } - -// GetRequestIDHeader safely fetches the value for global configuration 'RequestIDHeader' field -func GetRequestIDHeader() string { return global.GetRequestIDHeader() } - -// SetRequestIDHeader safely sets the value for global configuration 'RequestIDHeader' field -func SetRequestIDHeader(v string) { global.SetRequestIDHeader(v) } |