notify

var (
	HelpAMQP = config.HelpKV{
		config.State:            "(Required) Is this server endpoint configuration active/enabled",
		config.Comment:          "A comment to describe the AMQP target setting",
		target.AmqpURL:          "(Required) AMQP server endpoint, e.g. `amqp://myuser:mypassword@localhost:5672`",
		target.AmqpExchange:     "Name of the AMQP exchange",
		target.AmqpExchangeType: "Kind of AMQP exchange type",
		target.AmqpRoutingKey:   "Routing key for publishing",
		target.AmqpMandatory:    "Set this to 'on' for server to return an unroutable message with a Return method. If this flag is 'off', the server silently drops the message",
		target.AmqpDurable:      "Set this to 'on' for queue to surive broker restarts",
		target.AmqpNoWait:       "When no_wait is 'on', declare without waiting for a confirmation from the server",
		target.AmqpInternal:     "Set this to 'on' for exchange to be not used directly by publishers, but only when bound to other exchanges",
		target.AmqpAutoDeleted:  "Set this to 'on' for queue that has had at least one consumer is deleted when last consumer unsubscribes",
		target.AmqpDeliveryMode: "Delivery queue implementation use non-persistent (1) or persistent (2)",
		target.AmqpQueueLimit:   "Enable persistent event store queue limit, defaults to '10000'",
		target.AmqpQueueDir:     "Local directory where events are stored eg: '/home/events'",
	}

	HelpKafka = config.HelpKV{
		config.State:              "(Required) Is this server endpoint configuration active/enabled",
		config.Comment:            "A comment to describe the Kafka target setting",
		target.KafkaTopic:         "The Kafka topic for a given message",
		target.KafkaBrokers:       "Command separated list of Kafka broker addresses",
		target.KafkaSASLUsername:  "Username for SASL/PLAIN  or SASL/SCRAM authentication",
		target.KafkaSASLPassword:  "Password for SASL/PLAIN  or SASL/SCRAM authentication",
		target.KafkaTLSClientAuth: "ClientAuth determines the Kafka server's policy for TLS client auth",
		target.KafkaSASL:          "Set this to 'on' to enable SASL authentication",
		target.KafkaTLS:           "Set this to 'on' to enable TLS",
		target.KafkaTLSSkipVerify: "Set this to 'on' to disable client verification of server certificate chain",
		target.KafkaQueueLimit:    "Enable persistent event store queue limit, defaults to '10000'",
		target.KafkaQueueDir:      "Local directory where events are stored eg: '/home/events'",
	}

	HelpMQTT = config.HelpKV{
		config.State:                 "(Required) Is this server endpoint configuration active/enabled",
		config.Comment:               "A comment to describe the MQTT target setting",
		target.MqttBroker:            "(Required) MQTT server endpoint, e.g. `tcp://localhost:1883`",
		target.MqttTopic:             "(Required) Name of the MQTT topic to publish on, e.g. `minio`",
		target.MqttUsername:          "Username to connect to the MQTT server (if required)",
		target.MqttPassword:          "Password to connect to the MQTT server (if required)",
		target.MqttQoS:               "Set the Quality of Service Level for MQTT endpoint",
		target.MqttKeepAliveInterval: "Optional keep alive interval for MQTT connections",
		target.MqttReconnectInterval: "Optional reconnect interval for MQTT connections",
		target.MqttQueueDir:          "Local directory where events are stored eg: '/home/events'",
		target.MqttQueueLimit:        "Enable persistent event store queue limit, defaults to '10000'",
	}

	HelpES = config.HelpKV{
		config.State:             "(Required) Is this server endpoint configuration active/enabled",
		config.Comment:           "A comment to describe the Elasticsearch target setting",
		target.ElasticURL:        "(Required) The Elasticsearch server's address, with optional authentication info",
		target.ElasticFormat:     "(Required) Either `namespace` or `access`, defaults to 'namespace'",
		target.ElasticIndex:      "(Required) The name of an Elasticsearch index in which MinIO will store document",
		target.ElasticQueueDir:   "Local directory where events are stored eg: '/home/events'",
		target.ElasticQueueLimit: "Enable persistent event store queue limit, defaults to '10000'",
	}

	HelpWebhook = config.HelpKV{
		config.State:             "(Required) Is this server endpoint configuration active/enabled",
		config.Comment:           "A comment to describe the Webhook target setting",
		target.WebhookEndpoint:   "Webhook server endpoint eg: http://localhost:8080/minio/events",
		target.WebhookAuthToken:  "Authorization token used for webhook server endpoint (optional)",
		target.WebhookQueueLimit: "Enable persistent event store queue limit, defaults to '10000'",
		target.WebhookQueueDir:   "Local directory where events are stored eg: '/home/events'",
	}

	HelpRedis = config.HelpKV{
		config.State:           "(Required) Is this server endpoint configuration active/enabled",
		config.Comment:         "A comment to describe the Redis target setting",
		target.RedisFormat:     "Specify how data is populated, a hash is used in case of `namespace` format and a list in case of `access` format, defaults to 'namespace'",
		target.RedisAddress:    "(Required) The Redis server's address. For example: `localhost:6379`",
		target.RedisKey:        "The name of the redis key under which events are stored",
		target.RedisPassword:   "(Optional) The Redis server's password",
		target.RedisQueueDir:   "Local directory where events are stored eg: '/home/events'",
		target.RedisQueueLimit: "Enable persistent event store queue limit, defaults to '10000'",
	}

	HelpPostgres = config.HelpKV{
		config.State:                    "(Required) Is this server endpoint configuration active/enabled",
		config.Comment:                  "A comment to describe the Postgres target setting",
		target.PostgresFormat:           "Specify how data is populated, `namespace` format and `access` format, defaults to 'namespace'",
		target.PostgresConnectionString: "Connection string parameters for the PostgreSQL server",
		target.PostgresTable:            "(Required) Table name in which events will be stored/updated. If the table does not exist, the MinIO server creates it at start-up",
		target.PostgresHost:             "(Optional) Host name of the PostgreSQL server. Defaults to `localhost`. IPv6 host should be enclosed with `[` and `]`",
		target.PostgresPort:             "(Optional) Port on which to connect to PostgreSQL server, defaults to `5432`",
		target.PostgresUsername:         "Database username, defaults to user running the MinIO process if not specified",
		target.PostgresPassword:         "Database password",
		target.PostgresDatabase:         "Database name",
		target.PostgresQueueDir:         "Local directory where events are stored eg: '/home/events'",
		target.PostgresQueueLimit:       "Enable persistent event store queue limit, defaults to '10000'",
	}

	HelpMySQL = config.HelpKV{
		config.State:           "(Required) Is this server endpoint configuration active/enabled",
		config.Comment:         "A comment to describe the MySQL target setting",
		target.MySQLFormat:     "Specify how data is populated, `namespace` format and `access` format, defaults to 'namespace'",
		target.MySQLHost:       "Host name of the MySQL server (used only if `dsnString` is empty)",
		target.MySQLPort:       "Port on which to connect to the MySQL server (used only if `dsn_string` is empty)",
		target.MySQLUsername:   "Database user-name (used only if `dsnString` is empty)",
		target.MySQLPassword:   "Database password (used only if `dsnString` is empty)",
		target.MySQLDatabase:   "Database name (used only if `dsnString` is empty)",
		target.MySQLDSNString:  "Data-Source-Name connection string for the MySQL server",
		target.MySQLTable:      "(Required) Table name in which events will be stored/updated. If the table does not exist, the MinIO server creates it at start-up",
		target.MySQLQueueLimit: "Enable persistent event store queue limit, defaults to '10000'",
		target.MySQLQueueDir:   "Local directory where events are stored eg: '/home/events'",
	}

	HelpNATS = config.HelpKV{
		config.State:                           "(Required) Is this server endpoint configuration active/enabled",
		config.Comment:                         "A comment to describe the NATS target setting",
		target.NATSAddress:                     "NATS server address eg: '0.0.0.0:4222'",
		target.NATSSubject:                     "NATS subject that represents this subscription",
		target.NATSUsername:                    "Username to be used when connecting to the server",
		target.NATSPassword:                    "Password to be used when connecting to a server",
		target.NATSToken:                       "Token to be used when connecting to a server",
		target.NATSSecure:                      "Set this to 'on', enables TLS secure connections that skip server verification (not recommended)",
		target.NATSPingInterval:                "Client ping commands interval to the server, disabled by default",
		target.NATSStreaming:                   "Set this to 'on', to use streaming NATS server",
		target.NATSStreamingAsync:              "Set this to 'on', to enable asynchronous publish, process the ACK or error state",
		target.NATSStreamingMaxPubAcksInFlight: "Specifies how many messages can be published without getting ACKs back from NATS streaming server",
		target.NATSStreamingClusterID:          "Unique ID for the NATS streaming cluster",
		target.NATSQueueLimit:                  "Enable persistent event store queue limit, defaults to '10000'",
		target.NATSQueueDir:                    "Local directory where events are stored eg: '/home/events'",
		target.NATSCertAuthority:               "Certificate chain of the target NATS server if self signed certs were used",
		target.NATSClientCert:                  "TLS Cert used to authenticate against NATS configured to require client certificates",
		target.NATSClientKey:                   "TLS Key used to authenticate against NATS configured to require client certificates",
	}

	HelpNSQ = config.HelpKV{
		config.State:            "(Required) Is this server endpoint configuration active/enabled",
		config.Comment:          "A comment to describe the NSQ target setting",
		target.NSQAddress:       "NSQ server address eg: '127.0.0.1:4150'",
		target.NSQTopic:         "NSQ topic unique per target",
		target.NSQTLS:           "Set this to 'on', to enable TLS negotiation",
		target.NSQTLSSkipVerify: "Set this to 'on', to disable client verification of server certificates",
		target.NSQQueueLimit:    "Enable persistent event store queue limit, defaults to '10000'",
		target.NSQQueueDir:      "Local directory where events are stored eg: '/home/events'",
	}
)

var (
	DefaultAMQPKVS = config.KVS{
		config.State:            config.StateOff,
		config.Comment:          "Default settings for AMQP notification",
		target.AmqpURL:          "",
		target.AmqpExchange:     "",
		target.AmqpExchangeType: "",
		target.AmqpRoutingKey:   "",
		target.AmqpMandatory:    config.StateOff,
		target.AmqpDurable:      config.StateOff,
		target.AmqpNoWait:       config.StateOff,
		target.AmqpInternal:     config.StateOff,
		target.AmqpAutoDeleted:  config.StateOff,
		target.AmqpDeliveryMode: "0",
		target.AmqpQueueLimit:   "0",
		target.AmqpQueueDir:     "",
	}
)

var (
	DefaultESKVS = config.KVS{
		config.State:             config.StateOff,
		config.Comment:           "Default settings for Elasticsearch notification",
		target.ElasticURL:        "",
		target.ElasticFormat:     formatNamespace,
		target.ElasticIndex:      "",
		target.ElasticQueueDir:   "",
		target.ElasticQueueLimit: "0",
	}
)

var (
	DefaultKafkaKVS = config.KVS{
		config.State:              config.StateOff,
		config.Comment:            "Default settings for Kafka notification",
		target.KafkaTopic:         "",
		target.KafkaBrokers:       "",
		target.KafkaSASLUsername:  "",
		target.KafkaSASLPassword:  "",
		target.KafkaTLSClientAuth: "0",
		target.KafkaSASL:          config.StateOff,
		target.KafkaTLS:           config.StateOff,
		target.KafkaTLSSkipVerify: config.StateOff,
		target.KafkaQueueLimit:    "0",
		target.KafkaQueueDir:      "",
	}
)

var (
	DefaultMQTTKVS = config.KVS{
		config.State:                 config.StateOff,
		config.Comment:               "Default settings for MQTT notification",
		target.MqttBroker:            "",
		target.MqttTopic:             "",
		target.MqttPassword:          "",
		target.MqttUsername:          "",
		target.MqttQoS:               "0",
		target.MqttKeepAliveInterval: "0s",
		target.MqttReconnectInterval: "0s",
		target.MqttQueueDir:          "",
		target.MqttQueueLimit:        "0",
	}
)

var (
	DefaultMySQLKVS = config.KVS{
		config.State:           config.StateOff,
		config.Comment:         "Default settings for MySQL notification",
		target.MySQLFormat:     formatNamespace,
		target.MySQLHost:       "",
		target.MySQLPort:       "",
		target.MySQLUsername:   "",
		target.MySQLPassword:   "",
		target.MySQLDatabase:   "",
		target.MySQLDSNString:  "",
		target.MySQLTable:      "",
		target.MySQLQueueLimit: "0",
		target.MySQLQueueDir:   "",
	}
)

var (
	DefaultNATSKVS = config.KVS{
		config.State:                           config.StateOff,
		config.Comment:                         "Default settings for NATS notification",
		target.NATSAddress:                     "",
		target.NATSSubject:                     "",
		target.NATSUsername:                    "",
		target.NATSPassword:                    "",
		target.NATSToken:                       "",
		target.NATSCertAuthority:               "",
		target.NATSClientCert:                  "",
		target.NATSClientKey:                   "",
		target.NATSSecure:                      config.StateOff,
		target.NATSPingInterval:                "0",
		target.NATSQueueLimit:                  "0",
		target.NATSQueueDir:                    "",
		target.NATSStreaming:                   config.StateOff,
		target.NATSStreamingAsync:              config.StateOff,
		target.NATSStreamingMaxPubAcksInFlight: "0",
		target.NATSStreamingClusterID:          "",
	}
)

var (
	DefaultNSQKVS = config.KVS{
		config.State:            config.StateOff,
		config.Comment:          "Default settings for NSQ notification",
		target.NSQAddress:       "",
		target.NSQTopic:         "",
		target.NSQTLS:           config.StateOff,
		target.NSQTLSSkipVerify: config.StateOff,
		target.NSQQueueLimit:    "0",
		target.NSQQueueDir:      "",
	}
)

var (
	DefaultNotificationKVS = map[string]config.KVS{
		config.NotifyAMQPSubSys:     DefaultAMQPKVS,
		config.NotifyKafkaSubSys:    DefaultKafkaKVS,
		config.NotifyMQTTSubSys:     DefaultMQTTKVS,
		config.NotifyMySQLSubSys:    DefaultMySQLKVS,
		config.NotifyNATSSubSys:     DefaultNATSKVS,
		config.NotifyNSQSubSys:      DefaultNSQKVS,
		config.NotifyPostgresSubSys: DefaultPostgresKVS,
		config.NotifyRedisSubSys:    DefaultRedisKVS,
		config.NotifyWebhookSubSys:  DefaultWebhookKVS,
		config.NotifyESSubSys:       DefaultESKVS,
	}
)

var (
	DefaultPostgresKVS = config.KVS{
		config.State:                    config.StateOff,
		config.Comment:                  "Default settings for Postgres notification",
		target.PostgresFormat:           formatNamespace,
		target.PostgresConnectionString: "",
		target.PostgresTable:            "",
		target.PostgresHost:             "",
		target.PostgresPort:             "",
		target.PostgresUsername:         "",
		target.PostgresPassword:         "",
		target.PostgresDatabase:         "",
		target.PostgresQueueDir:         "",
		target.PostgresQueueLimit:       "0",
	}
)

var (
	DefaultRedisKVS = config.KVS{
		config.State:           config.StateOff,
		config.Comment:         "Default settings for Redis notification",
		target.RedisFormat:     formatNamespace,
		target.RedisAddress:    "",
		target.RedisKey:        "",
		target.RedisPassword:   "",
		target.RedisQueueDir:   "",
		target.RedisQueueLimit: "0",
	}
)

var (
	DefaultWebhookKVS = config.KVS{
		config.State:             config.StateOff,
		config.Comment:           "Default settings for Webhook notification",
		target.WebhookEndpoint:   "",
		target.WebhookAuthToken:  "",
		target.WebhookQueueLimit: "0",
		target.WebhookQueueDir:   "",
	}
)