{
  "description": "ClusterOutput is the Schema for the clusteroutputs API",
  "properties": {
    "apiVersion": {
      "description": "APIVersion defines the versioned schema of this representation of an object.\nServers should convert recognized schemas to the latest internal value, and\nmay reject unrecognized values.\nMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources",
      "type": [
        "string",
        "null"
      ]
    },
    "kind": {
      "description": "Kind is a string value representing the REST resource this object represents.\nServers may infer this from the endpoint the client submits requests to.\nCannot be updated.\nIn CamelCase.\nMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds",
      "type": [
        "string",
        "null"
      ]
    },
    "metadata": {
      "type": [
        "object",
        "null"
      ]
    },
    "spec": {
      "additionalProperties": false,
      "description": "ClusterOutputSpec defines the desired state of ClusterOutput",
      "properties": {
        "outputs": {
          "items": {
            "additionalProperties": false,
            "description": "Output defines all available output plugins and their parameters",
            "properties": {
              "buffer": {
                "additionalProperties": false,
                "description": "buffer section",
                "properties": {
                  "calcNumRecords": {
                    "description": "Calculates the number of records, chunk size, during chunk resume.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "chunkFormat": {
                    "description": "ChunkFormat specifies the chunk format for calc_num_records.",
                    "enum": [
                      "msgpack",
                      "text",
                      "auto"
                    ],
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "chunkLimitRecords": {
                    "description": "The max number of events that each chunks can store in it.",
                    "pattern": "^\\d+(KB|MB|GB|TB)$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "chunkLimitSize": {
                    "description": "Buffer parameters\nThe max size of each chunks: events will be written into chunks until the size of chunks become this size\nDefault: 8MB (memory) / 256MB (file)",
                    "pattern": "^\\d+(KB|MB|GB|TB)$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "compress": {
                    "description": "Fluentd will decompress these compressed chunks automatically before passing them to the output plugin\nIf gzip is set, Fluentd compresses data records before writing to buffer chunks.\nDefault:text.",
                    "enum": [
                      "text",
                      "gzip"
                    ],
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "delayedCommitTimeout": {
                    "description": "The timeout (seconds) until output plugin decides if the async write operation has failed. Default is 60s",
                    "pattern": "^\\d+(\\.[0-9]{0,2})?(s|m|h|d)?$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "disableChunkBackup": {
                    "description": "Instead of storing unrecoverable chunks in the backup directory, just discard them. This option is new in Fluentd v1.2.6.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "flushAtShutdown": {
                    "description": "Flush parameters\nThis specifies whether to flush/write all buffer chunks on shutdown or not.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "flushInterval": {
                    "description": "FlushInterval defines the flush interval",
                    "pattern": "^\\d+(\\.[0-9]{0,2})?(s|m|h|d)?$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "flushMode": {
                    "description": "FlushMode defines the flush mode:\nlazy: flushes/writes chunks once per timekey\ninterval: flushes/writes chunks per specified time via flush_interval\nimmediate: flushes/writes chunks immediately after events are appended into chunks\ndefault: equals to lazy if time is specified as chunk key, interval otherwise",
                    "enum": [
                      "default",
                      "lazy",
                      "interval",
                      "immediate"
                    ],
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "flushThreadCount": {
                    "description": "The number of threads to flush/write chunks in parallel",
                    "pattern": "^\\d+$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "id": {
                    "description": "The @id parameter specifies a unique name for the configuration.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "localtime": {
                    "description": "If true, uses local time.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "logLevel": {
                    "description": "The @log_level parameter specifies the plugin-specific logging level",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "overflowAction": {
                    "description": "OverflowAtction defines the output plugin behave when its buffer queue is full.\nDefault: throw_exception",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "path": {
                    "description": "The path where buffer chunks are stored. This field would make no effect in memory buffer plugin.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "pathSuffix": {
                    "description": "Changes the suffix of the buffer file.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "queueLimitLength": {
                    "description": "The queue length limitation of this buffer plugin instance. Default: 0.95",
                    "pattern": "^\\d+.?\\d+$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "queuedChunksLimitSize": {
                    "description": "Limit the number of queued chunks. Default: 1\nIf a smaller flush_interval is set, e.g. 1s,\nthere are lots of small queued chunks in the buffer.\nWith file buffer, it may consume a lot of fd resources when output destination has a problem.\nThis parameter mitigates such situations.",
                    "minimum": 1,
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "retryExponentialBackoffBase": {
                    "description": "The base number of exponential backoff for retries.",
                    "pattern": "^\\d+(\\.[0-9]{0,2})?$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "retryForever": {
                    "description": "If true, plugin will ignore retry_timeout and retry_max_times options and retry flushing forever.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "retryMaxInterval": {
                    "description": "The maximum interval (seconds) for exponential backoff between retries while failing",
                    "pattern": "^\\d+(\\.[0-9]{0,2})?(s|m|h|d)?$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "retryMaxTimes": {
                    "description": "The maximum number of times to retry to flush the failed chunks. Default: none",
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "retryRandomize": {
                    "description": "If true, the output plugin will retry after randomized interval not to do burst retries",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "retrySecondaryThreshold": {
                    "description": "The ratio of retry_timeout to switch to use the secondary while failing.",
                    "pattern": "^\\d+.?\\d+$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "retryTimeout": {
                    "description": "Retry parameters\nThe maximum time (seconds) to retry to flush again the failed chunks, until the plugin discards the buffer chunks",
                    "pattern": "^\\d+(\\.[0-9]{0,2})?(s|m|h|d)?$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "retryType": {
                    "description": "Output plugin will retry periodically with fixed intervals.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "retryWait": {
                    "description": "Wait in seconds before the next retry to flush or constant factor of exponential backoff",
                    "pattern": "^\\d+(\\.[0-9]{0,2})?(s|m|h|d)?$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "tag": {
                    "description": "The output plugins group events into chunks.\nChunk keys, specified as the argument of \u003cbuffer\u003e section, control how to group events into chunks.\nIf tag is empty, which means blank Chunk Keys.\nTag also supports Nested Field, combination of Chunk Keys, placeholders, etc.\nSee https://docs.fluentd.org/configuration/buffer-section.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "timeFormat": {
                    "description": "Process value according to the specified format. This is available only when time_type is string",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "timeFormatFallbacks": {
                    "description": "Uses the specified time format as a fallback in the specified order. You can parse undetermined time format by using time_format_fallbacks. This options is enabled when time_type is mixed.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "timeType": {
                    "description": "parses/formats value according to this type, default is string",
                    "enum": [
                      "float",
                      "unixtime",
                      "string",
                      "mixed"
                    ],
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "timekey": {
                    "description": "Output plugin will flush chunks per specified time (enabled when time is specified in chunk keys)",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "timekeyWait": {
                    "description": "Output plugin will write chunks after timekey_wait seconds later after timekey expiration",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "timezone": {
                    "description": "Uses the specified timezone.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "totalLimitSize": {
                    "description": "The size limitation of this buffer plugin instance\nDefault: 512MB (memory) / 64GB (file)",
                    "pattern": "^\\d+(KB|MB|GB|TB)$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "type": {
                    "description": "The @type parameter specifies the type of the plugin.",
                    "enum": [
                      "file",
                      "memory",
                      "file_single"
                    ],
                    "type": "string"
                  },
                  "utc": {
                    "description": "If true, uses UTC.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  }
                },
                "required": [
                  "type"
                ],
                "type": [
                  "object",
                  "null"
                ]
              },
              "cloudWatch": {
                "additionalProperties": false,
                "description": "out_cloudwatch plugin",
                "properties": {
                  "autoCreateStream": {
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "awsEcsAuthentication": {
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "awsKeyId": {
                    "additionalProperties": false,
                    "description": "Secret defines the key of a value.",
                    "properties": {
                      "valueFrom": {
                        "additionalProperties": false,
                        "description": "ValueSource defines how to find a value's key.",
                        "properties": {
                          "secretKeyRef": {
                            "additionalProperties": false,
                            "description": "Selects a key of a secret in the pod's namespace",
                            "properties": {
                              "key": {
                                "description": "The key of the secret to select from.  Must be a valid secret key.",
                                "type": "string"
                              },
                              "name": {
                                "default": "",
                                "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                "type": [
                                  "string",
                                  "null"
                                ]
                              },
                              "optional": {
                                "description": "Specify whether the Secret or its key must be defined",
                                "type": [
                                  "boolean",
                                  "null"
                                ]
                              }
                            },
                            "required": [
                              "key"
                            ],
                            "type": [
                              "object",
                              "null"
                            ],
                            "x-kubernetes-map-type": "atomic"
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "awsSecKey": {
                    "additionalProperties": false,
                    "description": "Secret defines the key of a value.",
                    "properties": {
                      "valueFrom": {
                        "additionalProperties": false,
                        "description": "ValueSource defines how to find a value's key.",
                        "properties": {
                          "secretKeyRef": {
                            "additionalProperties": false,
                            "description": "Selects a key of a secret in the pod's namespace",
                            "properties": {
                              "key": {
                                "description": "The key of the secret to select from.  Must be a valid secret key.",
                                "type": "string"
                              },
                              "name": {
                                "default": "",
                                "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                "type": [
                                  "string",
                                  "null"
                                ]
                              },
                              "optional": {
                                "description": "Specify whether the Secret or its key must be defined",
                                "type": [
                                  "boolean",
                                  "null"
                                ]
                              }
                            },
                            "required": [
                              "key"
                            ],
                            "type": [
                              "object",
                              "null"
                            ],
                            "x-kubernetes-map-type": "atomic"
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "awsStsDurationSeconds": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "awsStsEndpointUrl": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "awsStsExternalId": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "awsStsPolicy": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "awsStsRoleArn": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "awsStsSessionName": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "awsUseSts": {
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "concurrency": {
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "durationSeconds": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "endpoint": {
                    "description": "Specify an AWS endpoint to send data to.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "httpProxy": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "includeTimeKey": {
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "jsonHandler": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "localtime": {
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "logGroupAwsTags": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "logGroupAwsTagsKey": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "logGroupName": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "logGroupNameKey": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "logRejectedRequest": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "logStreamName": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "logStreamNameKey": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "maxEventsPerBatch": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "maxMessageLength": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "messageKeys": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "policy": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "putLogEventsDisableRetryLimit": {
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "putLogEventsRetryLimit": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "putLogEventsRetryWait": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "region": {
                    "description": "The AWS region.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "removeLogGroupAwsTagsKey": {
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "removeLogGroupNameKey": {
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "removeLogStreamNameKey": {
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "removeRetentionInDaysKey": {
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "retentionInDays": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "retentionInDaysKey": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "roleArn": {
                    "description": "ARN of an IAM role to assume (for cross account access).",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "roleSessionName": {
                    "description": "Role Session name",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "sslVerifyPeer": {
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "useTagAsGroup": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "useTagAsStream": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "webIdentityTokenFile": {
                    "description": "Web identity token file",
                    "type": [
                      "string",
                      "null"
                    ]
                  }
                },
                "type": [
                  "object",
                  "null"
                ]
              },
              "copy": {
                "additionalProperties": false,
                "description": "copy plugin",
                "properties": {
                  "copyMode": {
                    "description": "CopyMode defines how to pass the events to \u003cstore\u003e plugins.",
                    "enum": [
                      "no_copy",
                      "shallow",
                      "deep",
                      "marshal"
                    ],
                    "type": "string"
                  }
                },
                "required": [
                  "copyMode"
                ],
                "type": [
                  "object",
                  "null"
                ]
              },
              "customPlugin": {
                "additionalProperties": false,
                "description": "Custom plugin type",
                "properties": {
                  "config": {
                    "type": "string"
                  }
                },
                "required": [
                  "config"
                ],
                "type": [
                  "object",
                  "null"
                ]
              },
              "datadog": {
                "additionalProperties": false,
                "description": "datadog plugin",
                "properties": {
                  "apiKey": {
                    "additionalProperties": false,
                    "description": "This parameter is required in order to authenticate your fluent agent.",
                    "properties": {
                      "valueFrom": {
                        "additionalProperties": false,
                        "description": "ValueSource defines how to find a value's key.",
                        "properties": {
                          "secretKeyRef": {
                            "additionalProperties": false,
                            "description": "Selects a key of a secret in the pod's namespace",
                            "properties": {
                              "key": {
                                "description": "The key of the secret to select from.  Must be a valid secret key.",
                                "type": "string"
                              },
                              "name": {
                                "default": "",
                                "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                "type": [
                                  "string",
                                  "null"
                                ]
                              },
                              "optional": {
                                "description": "Specify whether the Secret or its key must be defined",
                                "type": [
                                  "boolean",
                                  "null"
                                ]
                              }
                            },
                            "required": [
                              "key"
                            ],
                            "type": [
                              "object",
                              "null"
                            ],
                            "x-kubernetes-map-type": "atomic"
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "compressionLevel": {
                    "description": "Set the log compression level for HTTP (1 to 9, 9 being the best ratio)",
                    "format": "int32",
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "ddHostname": {
                    "description": "Used by Datadog to identify the host submitting the logs.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "ddSource": {
                    "description": "This tells Datadog what integration it is",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "ddSourcecategory": {
                    "description": "Multiple value attribute. Can be used to refine the source attribute",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "ddTags": {
                    "description": "Custom tags with the following format \"key1:value1, key2:value2\"",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "host": {
                    "description": "Proxy endpoint when logs are not directly forwarded to Datadog",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "httpProxy": {
                    "description": "HTTP proxy, only takes effect if HTTP forwarding is enabled (use_http). Defaults to HTTP_PROXY/http_proxy env vars.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "includeTagKey": {
                    "description": "Automatically include the Fluentd tag in the record.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "maxBackoff": {
                    "description": "The maximum time waited between each retry in seconds",
                    "format": "int32",
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "maxRetries": {
                    "description": "The number of retries before the output plugin stops. Set to -1 for unlimited retries",
                    "format": "int32",
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "noSSLValidation": {
                    "description": "Disable SSL validation (useful for proxy forwarding)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "port": {
                    "description": "Proxy port when logs are not directly forwarded to Datadog and ssl is not used",
                    "format": "int32",
                    "maximum": 65535,
                    "minimum": 1,
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "service": {
                    "description": "Used by Datadog to correlate between logs, traces and metrics.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "sslPort": {
                    "description": "Port used to send logs over a SSL encrypted connection to Datadog. If use_http is disabled, use 10516 for the US region and 443 for the EU region.",
                    "format": "int32",
                    "maximum": 65535,
                    "minimum": 1,
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "tagKey": {
                    "description": "Where to store the Fluentd tag.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "timestampKey": {
                    "description": "Name of the attribute which will contain timestamp of the log event. If nil, timestamp attribute is not added.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "useCompression": {
                    "description": "Enable log compression for HTTP",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "useHTTP": {
                    "description": "Enable HTTP forwarding. If you disable it, make sure to change the port to 10514 or ssl_port to 10516",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "useJson": {
                    "description": "Event format, if true, the event is sent in json format. Othwerwise, in plain text.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "useSSL": {
                    "description": "If true, the agent initializes a secure connection to Datadog. In clear TCP otherwise.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  }
                },
                "type": [
                  "object",
                  "null"
                ]
              },
              "elasticsearch": {
                "additionalProperties": false,
                "description": "out_es plugin",
                "properties": {
                  "bulkMessageRequestThreshold": {
                    "description": "Optional, Configure bulk_message_request_threshold splitting threshold size.\nDefault value is -1 (unlimited).\nIf a bulk message exceeds this threshold, the request is split into multiple smaller requests.",
                    "format": "int32",
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "caFile": {
                    "description": "Optional, Absolute path to CA certificate file",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "clientCert": {
                    "description": "Optional, Absolute path to client Certificate file",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "clientKey": {
                    "description": "Optional, Absolute path to client private Key file",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "clientKeyPassword": {
                    "additionalProperties": false,
                    "description": "Optional, password for ClientKey file",
                    "properties": {
                      "valueFrom": {
                        "additionalProperties": false,
                        "description": "ValueSource defines how to find a value's key.",
                        "properties": {
                          "secretKeyRef": {
                            "additionalProperties": false,
                            "description": "Selects a key of a secret in the pod's namespace",
                            "properties": {
                              "key": {
                                "description": "The key of the secret to select from.  Must be a valid secret key.",
                                "type": "string"
                              },
                              "name": {
                                "default": "",
                                "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                "type": [
                                  "string",
                                  "null"
                                ]
                              },
                              "optional": {
                                "description": "Specify whether the Secret or its key must be defined",
                                "type": [
                                  "boolean",
                                  "null"
                                ]
                              }
                            },
                            "required": [
                              "key"
                            ],
                            "type": [
                              "object",
                              "null"
                            ],
                            "x-kubernetes-map-type": "atomic"
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "cloudAuth": {
                    "additionalProperties": false,
                    "description": "Authenticate towards Elastic Cloud using cloudAuth.",
                    "properties": {
                      "valueFrom": {
                        "additionalProperties": false,
                        "description": "ValueSource defines how to find a value's key.",
                        "properties": {
                          "secretKeyRef": {
                            "additionalProperties": false,
                            "description": "Selects a key of a secret in the pod's namespace",
                            "properties": {
                              "key": {
                                "description": "The key of the secret to select from.  Must be a valid secret key.",
                                "type": "string"
                              },
                              "name": {
                                "default": "",
                                "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                "type": [
                                  "string",
                                  "null"
                                ]
                              },
                              "optional": {
                                "description": "Specify whether the Secret or its key must be defined",
                                "type": [
                                  "boolean",
                                  "null"
                                ]
                              }
                            },
                            "required": [
                              "key"
                            ],
                            "type": [
                              "object",
                              "null"
                            ],
                            "x-kubernetes-map-type": "atomic"
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "cloudId": {
                    "additionalProperties": false,
                    "description": "Authenticate towards Elastic Cloud using CloudId. If set, cloudAuth must\nbe set as well and host, port, user and password are ignored.",
                    "properties": {
                      "valueFrom": {
                        "additionalProperties": false,
                        "description": "ValueSource defines how to find a value's key.",
                        "properties": {
                          "secretKeyRef": {
                            "additionalProperties": false,
                            "description": "Selects a key of a secret in the pod's namespace",
                            "properties": {
                              "key": {
                                "description": "The key of the secret to select from.  Must be a valid secret key.",
                                "type": "string"
                              },
                              "name": {
                                "default": "",
                                "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                "type": [
                                  "string",
                                  "null"
                                ]
                              },
                              "optional": {
                                "description": "Specify whether the Secret or its key must be defined",
                                "type": [
                                  "boolean",
                                  "null"
                                ]
                              }
                            },
                            "required": [
                              "key"
                            ],
                            "type": [
                              "object",
                              "null"
                            ],
                            "x-kubernetes-map-type": "atomic"
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "enableIlm": {
                    "description": "Optional, Enable Index Lifecycle Management (ILM)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "failOnPuttingTemplateRetryExceeded": {
                    "description": "Optional, Indicates whether to fail when max_retry_putting_template is exceeded. If you have multiple output plugin, you could use this property to do not fail on fluentd statup (default: false)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "host": {
                    "description": "The hostname of your Elasticsearch node (default: localhost).",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "hosts": {
                    "description": "Hosts defines a list of hosts if you want to connect to more than one Elasticsearch nodes",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "ilmPolicy": {
                    "description": "Optional, Specify ILM policy contents as Hash",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "ilmPolicyId": {
                    "description": "Optional, Specify ILM policy id",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "ilmPolicyOverride": {
                    "description": "Optional, Specify whether overwriting ilm policy or not",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "indexName": {
                    "description": "IndexName defines the placeholder syntax of Fluentd plugin API. See https://docs.fluentd.org/configuration/buffer-section.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "logEs400Reason": {
                    "description": "Optional, Enable logging of 400 reason without enabling debug log level",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "logstashFormat": {
                    "description": "If true, Fluentd uses the conventional index name format logstash-%Y.%m.%d (default: false). This option supersedes the index_name option.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "logstashPrefix": {
                    "description": "LogstashPrefix defines the logstash prefix index name to write events when logstash_format is true (default: logstash).",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "maxRetryPuttingTemplate": {
                    "description": "Optional, You can specify times of retry putting template (default: 10)",
                    "format": "int32",
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "password": {
                    "additionalProperties": false,
                    "description": "Optional, The login credentials to connect to Elasticsearch",
                    "properties": {
                      "valueFrom": {
                        "additionalProperties": false,
                        "description": "ValueSource defines how to find a value's key.",
                        "properties": {
                          "secretKeyRef": {
                            "additionalProperties": false,
                            "description": "Selects a key of a secret in the pod's namespace",
                            "properties": {
                              "key": {
                                "description": "The key of the secret to select from.  Must be a valid secret key.",
                                "type": "string"
                              },
                              "name": {
                                "default": "",
                                "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                "type": [
                                  "string",
                                  "null"
                                ]
                              },
                              "optional": {
                                "description": "Specify whether the Secret or its key must be defined",
                                "type": [
                                  "boolean",
                                  "null"
                                ]
                              }
                            },
                            "required": [
                              "key"
                            ],
                            "type": [
                              "object",
                              "null"
                            ],
                            "x-kubernetes-map-type": "atomic"
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "path": {
                    "description": "Path defines the REST API endpoint of Elasticsearch to post write requests (default: nil).",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "port": {
                    "description": "The port number of your Elasticsearch node (default: 9200).",
                    "format": "int32",
                    "maximum": 65535,
                    "minimum": 1,
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "reconnectOnError": {
                    "description": "Optional, Indicates that the plugin should reset connection on any error (reconnect on next send) (default: false)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "reloadAfter": {
                    "description": "Optional, When ReloadConnections true, this is the integer number of operations after which the plugin will reload the connections. The default value is 10000.",
                    "format": "int32",
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "reloadConnections": {
                    "description": "Optional, Automatically reload connection after 10000 documents (default: true)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "reloadOnFailure": {
                    "description": "Optional, Indicates that the elasticsearch-transport will try to reload the nodes addresses if there is a failure while making the request, this can be useful to quickly remove a dead node from the list of addresses (default: false)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "requestTimeout": {
                    "description": "Optional, HTTP Timeout (default: 5)",
                    "pattern": "^\\d+(s|m|h|d)$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "scheme": {
                    "description": "Specify https if your Elasticsearch endpoint supports SSL (default: http).",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "snifferClassName": {
                    "description": "Optional, Provide a different sniffer class name",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "sslVerify": {
                    "description": "Optional, Force certificate validation",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "suppressTypeName": {
                    "description": "Optional, Suppress '[types removal]' warnings on elasticsearch 7.x",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "templateOverwrite": {
                    "description": "Optional, Always update the template, even if it already exists (default: false)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "user": {
                    "additionalProperties": false,
                    "description": "Optional, The login credentials to connect to Elasticsearch",
                    "properties": {
                      "valueFrom": {
                        "additionalProperties": false,
                        "description": "ValueSource defines how to find a value's key.",
                        "properties": {
                          "secretKeyRef": {
                            "additionalProperties": false,
                            "description": "Selects a key of a secret in the pod's namespace",
                            "properties": {
                              "key": {
                                "description": "The key of the secret to select from.  Must be a valid secret key.",
                                "type": "string"
                              },
                              "name": {
                                "default": "",
                                "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                "type": [
                                  "string",
                                  "null"
                                ]
                              },
                              "optional": {
                                "description": "Specify whether the Secret or its key must be defined",
                                "type": [
                                  "boolean",
                                  "null"
                                ]
                              }
                            },
                            "required": [
                              "key"
                            ],
                            "type": [
                              "object",
                              "null"
                            ],
                            "x-kubernetes-map-type": "atomic"
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  }
                },
                "type": [
                  "object",
                  "null"
                ]
              },
              "elasticsearchDataStream": {
                "additionalProperties": false,
                "description": "out_es datastreams plugin",
                "properties": {
                  "bulkMessageRequestThreshold": {
                    "description": "Optional, Configure bulk_message_request_threshold splitting threshold size.\nDefault value is -1 (unlimited).\nIf a bulk message exceeds this threshold, the request is split into multiple smaller requests.",
                    "format": "int32",
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "caFile": {
                    "description": "Optional, Absolute path to CA certificate file",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "clientCert": {
                    "description": "Optional, Absolute path to client Certificate file",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "clientKey": {
                    "description": "Optional, Absolute path to client private Key file",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "clientKeyPassword": {
                    "additionalProperties": false,
                    "description": "Optional, password for ClientKey file",
                    "properties": {
                      "valueFrom": {
                        "additionalProperties": false,
                        "description": "ValueSource defines how to find a value's key.",
                        "properties": {
                          "secretKeyRef": {
                            "additionalProperties": false,
                            "description": "Selects a key of a secret in the pod's namespace",
                            "properties": {
                              "key": {
                                "description": "The key of the secret to select from.  Must be a valid secret key.",
                                "type": "string"
                              },
                              "name": {
                                "default": "",
                                "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                "type": [
                                  "string",
                                  "null"
                                ]
                              },
                              "optional": {
                                "description": "Specify whether the Secret or its key must be defined",
                                "type": [
                                  "boolean",
                                  "null"
                                ]
                              }
                            },
                            "required": [
                              "key"
                            ],
                            "type": [
                              "object",
                              "null"
                            ],
                            "x-kubernetes-map-type": "atomic"
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "cloudAuth": {
                    "additionalProperties": false,
                    "description": "Authenticate towards Elastic Cloud using cloudAuth.",
                    "properties": {
                      "valueFrom": {
                        "additionalProperties": false,
                        "description": "ValueSource defines how to find a value's key.",
                        "properties": {
                          "secretKeyRef": {
                            "additionalProperties": false,
                            "description": "Selects a key of a secret in the pod's namespace",
                            "properties": {
                              "key": {
                                "description": "The key of the secret to select from.  Must be a valid secret key.",
                                "type": "string"
                              },
                              "name": {
                                "default": "",
                                "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                "type": [
                                  "string",
                                  "null"
                                ]
                              },
                              "optional": {
                                "description": "Specify whether the Secret or its key must be defined",
                                "type": [
                                  "boolean",
                                  "null"
                                ]
                              }
                            },
                            "required": [
                              "key"
                            ],
                            "type": [
                              "object",
                              "null"
                            ],
                            "x-kubernetes-map-type": "atomic"
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "cloudId": {
                    "additionalProperties": false,
                    "description": "Authenticate towards Elastic Cloud using CloudId. If set, cloudAuth must\nbe set as well and host, port, user and password are ignored.",
                    "properties": {
                      "valueFrom": {
                        "additionalProperties": false,
                        "description": "ValueSource defines how to find a value's key.",
                        "properties": {
                          "secretKeyRef": {
                            "additionalProperties": false,
                            "description": "Selects a key of a secret in the pod's namespace",
                            "properties": {
                              "key": {
                                "description": "The key of the secret to select from.  Must be a valid secret key.",
                                "type": "string"
                              },
                              "name": {
                                "default": "",
                                "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                "type": [
                                  "string",
                                  "null"
                                ]
                              },
                              "optional": {
                                "description": "Specify whether the Secret or its key must be defined",
                                "type": [
                                  "boolean",
                                  "null"
                                ]
                              }
                            },
                            "required": [
                              "key"
                            ],
                            "type": [
                              "object",
                              "null"
                            ],
                            "x-kubernetes-map-type": "atomic"
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "dataStreamIlmName": {
                    "description": "Optional, You can specify the name of an existing ILM policy, which will be applied to the data stream. If not present, it creates a new ILM default policy (unless data_stream_template_name is defined, in that case the ILM will be set to the one specified in the matching index template)",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "dataStreamIlmPolicy": {
                    "description": "Optional, You can specify the ILM policy contents as hash. If not present, it will apply the ILM default policy",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "dataStreamIlmPolicyOverwrite": {
                    "description": "Optional, Specify whether the data stream ILM policy should be overwritten",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "dataStreamName": {
                    "description": "You can specify Elasticsearch data stream name by this parameter. This parameter is mandatory for elasticsearch_data_stream",
                    "type": "string"
                  },
                  "dataStreamTemplateName": {
                    "description": "Optional, You can specify an existing matching index template for the data stream. If not present, it creates a new matching index template",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "dataStreamTemplateUseIndexPatternsWildcard": {
                    "description": "Optional, Specify whether index patterns should include a wildcard (*) when creating an index template. This is particularly useful to prevent errors in scenarios where index templates are generated automatically, and multiple services with distinct suffixes are in use",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "enableIlm": {
                    "description": "Optional, Enable Index Lifecycle Management (ILM)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "failOnPuttingTemplateRetryExceeded": {
                    "description": "Optional, Indicates whether to fail when max_retry_putting_template is exceeded. If you have multiple output plugin, you could use this property to do not fail on fluentd statup (default: false)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "host": {
                    "description": "The hostname of your Elasticsearch node (default: localhost).",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "hosts": {
                    "description": "Hosts defines a list of hosts if you want to connect to more than one Elasticsearch nodes",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "ilmPolicy": {
                    "description": "Optional, Specify ILM policy contents as Hash",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "ilmPolicyId": {
                    "description": "Optional, Specify ILM policy id",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "ilmPolicyOverride": {
                    "description": "Optional, Specify whether overwriting ilm policy or not",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "logEs400Reason": {
                    "description": "Optional, Enable logging of 400 reason without enabling debug log level",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "maxRetryPuttingTemplate": {
                    "description": "Optional, You can specify times of retry putting template (default: 10)",
                    "format": "int32",
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "password": {
                    "additionalProperties": false,
                    "description": "Optional, The login credentials to connect to Elasticsearch",
                    "properties": {
                      "valueFrom": {
                        "additionalProperties": false,
                        "description": "ValueSource defines how to find a value's key.",
                        "properties": {
                          "secretKeyRef": {
                            "additionalProperties": false,
                            "description": "Selects a key of a secret in the pod's namespace",
                            "properties": {
                              "key": {
                                "description": "The key of the secret to select from.  Must be a valid secret key.",
                                "type": "string"
                              },
                              "name": {
                                "default": "",
                                "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                "type": [
                                  "string",
                                  "null"
                                ]
                              },
                              "optional": {
                                "description": "Specify whether the Secret or its key must be defined",
                                "type": [
                                  "boolean",
                                  "null"
                                ]
                              }
                            },
                            "required": [
                              "key"
                            ],
                            "type": [
                              "object",
                              "null"
                            ],
                            "x-kubernetes-map-type": "atomic"
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "path": {
                    "description": "Path defines the REST API endpoint of Elasticsearch to post write requests (default: nil).",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "port": {
                    "description": "The port number of your Elasticsearch node (default: 9200).",
                    "format": "int32",
                    "maximum": 65535,
                    "minimum": 1,
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "reconnectOnError": {
                    "description": "Optional, Indicates that the plugin should reset connection on any error (reconnect on next send) (default: false)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "reloadAfter": {
                    "description": "Optional, When ReloadConnections true, this is the integer number of operations after which the plugin will reload the connections. The default value is 10000.",
                    "format": "int32",
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "reloadConnections": {
                    "description": "Optional, Automatically reload connection after 10000 documents (default: true)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "reloadOnFailure": {
                    "description": "Optional, Indicates that the elasticsearch-transport will try to reload the nodes addresses if there is a failure while making the request, this can be useful to quickly remove a dead node from the list of addresses (default: false)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "requestTimeout": {
                    "description": "Optional, HTTP Timeout (default: 5)",
                    "pattern": "^\\d+(s|m|h|d)$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "scheme": {
                    "description": "Specify https if your Elasticsearch endpoint supports SSL (default: http).",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "snifferClassName": {
                    "description": "Optional, Provide a different sniffer class name",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "sslVerify": {
                    "description": "Optional, Force certificate validation",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "suppressTypeName": {
                    "description": "Optional, Suppress '[types removal]' warnings on elasticsearch 7.x",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "templateOverwrite": {
                    "description": "Optional, Always update the template, even if it already exists (default: false)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "user": {
                    "additionalProperties": false,
                    "description": "Optional, The login credentials to connect to Elasticsearch",
                    "properties": {
                      "valueFrom": {
                        "additionalProperties": false,
                        "description": "ValueSource defines how to find a value's key.",
                        "properties": {
                          "secretKeyRef": {
                            "additionalProperties": false,
                            "description": "Selects a key of a secret in the pod's namespace",
                            "properties": {
                              "key": {
                                "description": "The key of the secret to select from.  Must be a valid secret key.",
                                "type": "string"
                              },
                              "name": {
                                "default": "",
                                "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                "type": [
                                  "string",
                                  "null"
                                ]
                              },
                              "optional": {
                                "description": "Specify whether the Secret or its key must be defined",
                                "type": [
                                  "boolean",
                                  "null"
                                ]
                              }
                            },
                            "required": [
                              "key"
                            ],
                            "type": [
                              "object",
                              "null"
                            ],
                            "x-kubernetes-map-type": "atomic"
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  }
                },
                "required": [
                  "dataStreamName"
                ],
                "type": [
                  "object",
                  "null"
                ]
              },
              "format": {
                "additionalProperties": false,
                "description": "format section",
                "properties": {
                  "delimiter": {
                    "description": "Delimiter for each field.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "id": {
                    "description": "The @id parameter specifies a unique name for the configuration.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "localtime": {
                    "description": "If true, uses local time.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "logLevel": {
                    "description": "The @log_level parameter specifies the plugin-specific logging level",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "newline": {
                    "description": "Specify newline characters.",
                    "enum": [
                      "lf",
                      "crlf"
                    ],
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "outputTag": {
                    "description": "Output tag field if true.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "outputTime": {
                    "description": "Output time field if true.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "timeFormat": {
                    "description": "Process value according to the specified format. This is available only when time_type is string",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "timeFormatFallbacks": {
                    "description": "Uses the specified time format as a fallback in the specified order. You can parse undetermined time format by using time_format_fallbacks. This options is enabled when time_type is mixed.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "timeType": {
                    "description": "parses/formats value according to this type, default is string",
                    "enum": [
                      "float",
                      "unixtime",
                      "string",
                      "mixed"
                    ],
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "timezone": {
                    "description": "Uses the specified timezone.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "type": {
                    "description": "The @type parameter specifies the type of the plugin.",
                    "enum": [
                      "out_file",
                      "json",
                      "ltsv",
                      "csv",
                      "msgpack",
                      "hash",
                      "single_value"
                    ],
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "utc": {
                    "description": "If true, uses UTC.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  }
                },
                "type": [
                  "object",
                  "null"
                ]
              },
              "forward": {
                "additionalProperties": false,
                "description": "out_forward plugin",
                "properties": {
                  "ackResponseTimeout": {
                    "description": "This option is used when require_ack_response is true. This default value is based on popular tcp_syn_retries.",
                    "pattern": "^\\d+(\\.[0-9]{0,2})?(s|m|h|d)?$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "connectTimeout": {
                    "description": "The connection timeout for the socket. When the connection is timed out during the connection establishment, Errno::ETIMEDOUT error is raised.",
                    "pattern": "^\\d+(\\.[0-9]{0,2})?(s|m|h|d)?$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "dnsRoundRobin": {
                    "description": "Enable client-side DNS round robin. Uniform randomly pick an IP address to send data when a hostname has several IP addresses.\nheartbeat_type udp is not available with dns_round_robintrue. Use heartbeat_type tcp or heartbeat_type none.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "expireDnsCache": {
                    "description": "Sets TTL to expire DNS cache in seconds. Set 0 not to use DNS Cache.",
                    "pattern": "^\\d+(\\.[0-9]{0,2})?(s|m|h|d)?$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "hardTimeout": {
                    "description": "The hard timeout used to detect server failure. The default value is equal to the send_timeout parameter.",
                    "pattern": "^\\d+(\\.[0-9]{0,2})?(s|m|h|d)?$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "heartbeatInterval": {
                    "description": "The interval of the heartbeat packer.",
                    "pattern": "^\\d+(\\.[0-9]{0,2})?(s|m|h|d)?$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "heartbeatType": {
                    "description": "Specifies the transport protocol for heartbeats. Set none to disable.",
                    "enum": [
                      "transport",
                      "tcp",
                      "udp",
                      "none"
                    ],
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "ignoreNetworkErrorsAtStartup": {
                    "description": "Ignores DNS resolution and errors at startup time.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "keepalive": {
                    "description": "Enables the keepalive connection.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "keepaliveTimeout": {
                    "description": "Timeout for keepalive. Default value is nil which means to keep the connection alive as long as possible.",
                    "pattern": "^\\d+(\\.[0-9]{0,2})?(s|m|h|d)?$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "phiFailureDetector": {
                    "description": "Use the \"Phi accrual failure detector\" to detect server failure.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "phiThreshold": {
                    "description": "The threshold parameter used to detect server faults.",
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "recoverWait": {
                    "description": "The wait time before accepting a server fault recovery.",
                    "pattern": "^\\d+(\\.[0-9]{0,2})?(s|m|h|d)?$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "requireAckResponse": {
                    "description": "Changes the protocol to at-least-once. The plugin waits the ack from destination's in_forward plugin.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "security": {
                    "additionalProperties": false,
                    "description": "ServiceDiscovery defines the security section",
                    "properties": {
                      "allowAnonymousSource": {
                        "description": "Allows the anonymous source. \u003cclient\u003e sections are required, if disabled.",
                        "type": [
                          "string",
                          "null"
                        ]
                      },
                      "selfHostname": {
                        "description": "The hostname.",
                        "type": [
                          "string",
                          "null"
                        ]
                      },
                      "sharedKey": {
                        "description": "The shared key for authentication.",
                        "type": [
                          "string",
                          "null"
                        ]
                      },
                      "user": {
                        "additionalProperties": false,
                        "description": "Defines user section directly.",
                        "properties": {
                          "password": {
                            "additionalProperties": false,
                            "description": "Secret defines the key of a value.",
                            "properties": {
                              "valueFrom": {
                                "additionalProperties": false,
                                "description": "ValueSource defines how to find a value's key.",
                                "properties": {
                                  "secretKeyRef": {
                                    "additionalProperties": false,
                                    "description": "Selects a key of a secret in the pod's namespace",
                                    "properties": {
                                      "key": {
                                        "description": "The key of the secret to select from.  Must be a valid secret key.",
                                        "type": "string"
                                      },
                                      "name": {
                                        "default": "",
                                        "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                        "type": [
                                          "string",
                                          "null"
                                        ]
                                      },
                                      "optional": {
                                        "description": "Specify whether the Secret or its key must be defined",
                                        "type": [
                                          "boolean",
                                          "null"
                                        ]
                                      }
                                    },
                                    "required": [
                                      "key"
                                    ],
                                    "type": [
                                      "object",
                                      "null"
                                    ],
                                    "x-kubernetes-map-type": "atomic"
                                  }
                                },
                                "type": [
                                  "object",
                                  "null"
                                ]
                              }
                            },
                            "type": [
                              "object",
                              "null"
                            ]
                          },
                          "username": {
                            "additionalProperties": false,
                            "description": "Secret defines the key of a value.",
                            "properties": {
                              "valueFrom": {
                                "additionalProperties": false,
                                "description": "ValueSource defines how to find a value's key.",
                                "properties": {
                                  "secretKeyRef": {
                                    "additionalProperties": false,
                                    "description": "Selects a key of a secret in the pod's namespace",
                                    "properties": {
                                      "key": {
                                        "description": "The key of the secret to select from.  Must be a valid secret key.",
                                        "type": "string"
                                      },
                                      "name": {
                                        "default": "",
                                        "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                        "type": [
                                          "string",
                                          "null"
                                        ]
                                      },
                                      "optional": {
                                        "description": "Specify whether the Secret or its key must be defined",
                                        "type": [
                                          "boolean",
                                          "null"
                                        ]
                                      }
                                    },
                                    "required": [
                                      "key"
                                    ],
                                    "type": [
                                      "object",
                                      "null"
                                    ],
                                    "x-kubernetes-map-type": "atomic"
                                  }
                                },
                                "type": [
                                  "object",
                                  "null"
                                ]
                              }
                            },
                            "type": [
                              "object",
                              "null"
                            ]
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      },
                      "userAuth": {
                        "description": "If true, user-based authentication is used.",
                        "type": [
                          "string",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "sendTimeout": {
                    "description": "The timeout time when sending event logs.",
                    "pattern": "^\\d+(\\.[0-9]{0,2})?(s|m|h|d)?$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "servers": {
                    "description": "Servers defines the servers section, at least one is required",
                    "items": {
                      "additionalProperties": false,
                      "description": "Server defines the common parameters for the server plugin",
                      "properties": {
                        "host": {
                          "description": "Host defines the IP address or host name of the server.",
                          "type": [
                            "string",
                            "null"
                          ]
                        },
                        "id": {
                          "description": "The @id parameter specifies a unique name for the configuration.",
                          "type": [
                            "string",
                            "null"
                          ]
                        },
                        "logLevel": {
                          "description": "The @log_level parameter specifies the plugin-specific logging level",
                          "type": [
                            "string",
                            "null"
                          ]
                        },
                        "name": {
                          "description": "Name defines the name of the server. Used for logging and certificate verification in TLS transport (when the host is the address).",
                          "type": [
                            "string",
                            "null"
                          ]
                        },
                        "password": {
                          "additionalProperties": false,
                          "description": "Password defines the password for authentication.",
                          "properties": {
                            "valueFrom": {
                              "additionalProperties": false,
                              "description": "ValueSource defines how to find a value's key.",
                              "properties": {
                                "secretKeyRef": {
                                  "additionalProperties": false,
                                  "description": "Selects a key of a secret in the pod's namespace",
                                  "properties": {
                                    "key": {
                                      "description": "The key of the secret to select from.  Must be a valid secret key.",
                                      "type": "string"
                                    },
                                    "name": {
                                      "default": "",
                                      "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                      "type": [
                                        "string",
                                        "null"
                                      ]
                                    },
                                    "optional": {
                                      "description": "Specify whether the Secret or its key must be defined",
                                      "type": [
                                        "boolean",
                                        "null"
                                      ]
                                    }
                                  },
                                  "required": [
                                    "key"
                                  ],
                                  "type": [
                                    "object",
                                    "null"
                                  ],
                                  "x-kubernetes-map-type": "atomic"
                                }
                              },
                              "type": [
                                "object",
                                "null"
                              ]
                            }
                          },
                          "type": [
                            "object",
                            "null"
                          ]
                        },
                        "port": {
                          "description": "Port defines the port number of the host. Note that both TCP packets (event stream) and UDP packets (heartbeat messages) are sent to this port.",
                          "type": [
                            "string",
                            "null"
                          ]
                        },
                        "sharedKey": {
                          "description": "SharedKey defines the shared key per server.",
                          "type": [
                            "string",
                            "null"
                          ]
                        },
                        "standby": {
                          "description": "Standby marks a node as the standby node for an Active-Standby model between Fluentd nodes.",
                          "type": [
                            "string",
                            "null"
                          ]
                        },
                        "type": {
                          "description": "The @type parameter specifies the type of the plugin.",
                          "type": [
                            "string",
                            "null"
                          ]
                        },
                        "username": {
                          "additionalProperties": false,
                          "description": "Username defines the username for authentication.",
                          "properties": {
                            "valueFrom": {
                              "additionalProperties": false,
                              "description": "ValueSource defines how to find a value's key.",
                              "properties": {
                                "secretKeyRef": {
                                  "additionalProperties": false,
                                  "description": "Selects a key of a secret in the pod's namespace",
                                  "properties": {
                                    "key": {
                                      "description": "The key of the secret to select from.  Must be a valid secret key.",
                                      "type": "string"
                                    },
                                    "name": {
                                      "default": "",
                                      "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                      "type": [
                                        "string",
                                        "null"
                                      ]
                                    },
                                    "optional": {
                                      "description": "Specify whether the Secret or its key must be defined",
                                      "type": [
                                        "boolean",
                                        "null"
                                      ]
                                    }
                                  },
                                  "required": [
                                    "key"
                                  ],
                                  "type": [
                                    "object",
                                    "null"
                                  ],
                                  "x-kubernetes-map-type": "atomic"
                                }
                              },
                              "type": [
                                "object",
                                "null"
                              ]
                            }
                          },
                          "type": [
                            "object",
                            "null"
                          ]
                        },
                        "weight": {
                          "description": "Weight defines the load balancing weight",
                          "type": [
                            "string",
                            "null"
                          ]
                        }
                      },
                      "type": "object"
                    },
                    "type": "array"
                  },
                  "serviceDiscovery": {
                    "additionalProperties": false,
                    "description": "ServiceDiscovery defines the service_discovery section",
                    "properties": {
                      "confEncoding": {
                        "description": "The encoding of the configuration file.",
                        "type": [
                          "string",
                          "null"
                        ]
                      },
                      "dnsLookup": {
                        "description": "DnsLookup resolves the hostname to IP address of the SRV's Target.",
                        "type": [
                          "string",
                          "null"
                        ]
                      },
                      "dnsServerHost": {
                        "description": "DnsServerHost defines the hostname of the DNS server to request the SRV record.",
                        "type": [
                          "string",
                          "null"
                        ]
                      },
                      "hostname": {
                        "description": "The name in RFC2782.",
                        "type": [
                          "string",
                          "null"
                        ]
                      },
                      "id": {
                        "description": "The @id parameter specifies a unique name for the configuration.",
                        "type": [
                          "string",
                          "null"
                        ]
                      },
                      "interval": {
                        "description": "Interval defines the interval of sending requests to DNS server.",
                        "type": [
                          "string",
                          "null"
                        ]
                      },
                      "logLevel": {
                        "description": "The @log_level parameter specifies the plugin-specific logging level",
                        "type": [
                          "string",
                          "null"
                        ]
                      },
                      "path": {
                        "description": "The path of the target list. Default is '/etc/fluent/sd.yaml'",
                        "type": [
                          "string",
                          "null"
                        ]
                      },
                      "proto": {
                        "description": "Proto without the underscore in RFC2782.",
                        "type": [
                          "string",
                          "null"
                        ]
                      },
                      "server": {
                        "additionalProperties": false,
                        "description": "The server section of this plugin",
                        "properties": {
                          "host": {
                            "description": "Host defines the IP address or host name of the server.",
                            "type": [
                              "string",
                              "null"
                            ]
                          },
                          "id": {
                            "description": "The @id parameter specifies a unique name for the configuration.",
                            "type": [
                              "string",
                              "null"
                            ]
                          },
                          "logLevel": {
                            "description": "The @log_level parameter specifies the plugin-specific logging level",
                            "type": [
                              "string",
                              "null"
                            ]
                          },
                          "name": {
                            "description": "Name defines the name of the server. Used for logging and certificate verification in TLS transport (when the host is the address).",
                            "type": [
                              "string",
                              "null"
                            ]
                          },
                          "password": {
                            "additionalProperties": false,
                            "description": "Password defines the password for authentication.",
                            "properties": {
                              "valueFrom": {
                                "additionalProperties": false,
                                "description": "ValueSource defines how to find a value's key.",
                                "properties": {
                                  "secretKeyRef": {
                                    "additionalProperties": false,
                                    "description": "Selects a key of a secret in the pod's namespace",
                                    "properties": {
                                      "key": {
                                        "description": "The key of the secret to select from.  Must be a valid secret key.",
                                        "type": "string"
                                      },
                                      "name": {
                                        "default": "",
                                        "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                        "type": [
                                          "string",
                                          "null"
                                        ]
                                      },
                                      "optional": {
                                        "description": "Specify whether the Secret or its key must be defined",
                                        "type": [
                                          "boolean",
                                          "null"
                                        ]
                                      }
                                    },
                                    "required": [
                                      "key"
                                    ],
                                    "type": [
                                      "object",
                                      "null"
                                    ],
                                    "x-kubernetes-map-type": "atomic"
                                  }
                                },
                                "type": [
                                  "object",
                                  "null"
                                ]
                              }
                            },
                            "type": [
                              "object",
                              "null"
                            ]
                          },
                          "port": {
                            "description": "Port defines the port number of the host. Note that both TCP packets (event stream) and UDP packets (heartbeat messages) are sent to this port.",
                            "type": [
                              "string",
                              "null"
                            ]
                          },
                          "sharedKey": {
                            "description": "SharedKey defines the shared key per server.",
                            "type": [
                              "string",
                              "null"
                            ]
                          },
                          "standby": {
                            "description": "Standby marks a node as the standby node for an Active-Standby model between Fluentd nodes.",
                            "type": [
                              "string",
                              "null"
                            ]
                          },
                          "type": {
                            "description": "The @type parameter specifies the type of the plugin.",
                            "type": [
                              "string",
                              "null"
                            ]
                          },
                          "username": {
                            "additionalProperties": false,
                            "description": "Username defines the username for authentication.",
                            "properties": {
                              "valueFrom": {
                                "additionalProperties": false,
                                "description": "ValueSource defines how to find a value's key.",
                                "properties": {
                                  "secretKeyRef": {
                                    "additionalProperties": false,
                                    "description": "Selects a key of a secret in the pod's namespace",
                                    "properties": {
                                      "key": {
                                        "description": "The key of the secret to select from.  Must be a valid secret key.",
                                        "type": "string"
                                      },
                                      "name": {
                                        "default": "",
                                        "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                        "type": [
                                          "string",
                                          "null"
                                        ]
                                      },
                                      "optional": {
                                        "description": "Specify whether the Secret or its key must be defined",
                                        "type": [
                                          "boolean",
                                          "null"
                                        ]
                                      }
                                    },
                                    "required": [
                                      "key"
                                    ],
                                    "type": [
                                      "object",
                                      "null"
                                    ],
                                    "x-kubernetes-map-type": "atomic"
                                  }
                                },
                                "type": [
                                  "object",
                                  "null"
                                ]
                              }
                            },
                            "type": [
                              "object",
                              "null"
                            ]
                          },
                          "weight": {
                            "description": "Weight defines the load balancing weight",
                            "type": [
                              "string",
                              "null"
                            ]
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      },
                      "service": {
                        "description": "Service without the underscore in RFC2782.",
                        "type": [
                          "string",
                          "null"
                        ]
                      },
                      "type": {
                        "description": "The @type parameter specifies the type of the plugin.",
                        "enum": [
                          "static",
                          "file",
                          "srv"
                        ],
                        "type": "string"
                      }
                    },
                    "required": [
                      "type"
                    ],
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "tlsAllowSelfSignedCert": {
                    "description": "Allows self-signed certificates or not.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "tlsCertLogicalStoreName": {
                    "description": "The certificate logical store name on Windows system certstore. This parameter is for Windows only.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "tlsCertPath": {
                    "description": "The additional CA certificate path for TLS.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "tlsCertThumbprint": {
                    "description": "The certificate thumbprint for searching from Windows system certstore. This parameter is for Windows only.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "tlsCertUseEnterpriseStore": {
                    "description": "Enables the certificate enterprise store on Windows system certstore. This parameter is for Windows only.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "tlsCiphers": {
                    "description": "The cipher configuration of TLS transport.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "tlsClientCertPath": {
                    "description": "The client certificate path for TLS.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "tlsClientPrivateKeyPassphrase": {
                    "description": "The TLS private key passphrase for the client.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "tlsClientPrivateKeyPath": {
                    "description": "The client private key path for TLS.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "tlsInsecureMode": {
                    "description": "Skips all verification of certificates or not.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "tlsVerifyHostname": {
                    "description": "Verifies hostname of servers and certificates or not in TLS transport.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "tlsVersion": {
                    "description": "The default version of TLS transport.",
                    "enum": [
                      "TLSv1_1",
                      "TLSv1_2"
                    ],
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "verifyConnectionAtStartup": {
                    "description": "Verify that a connection can be made with one of out_forward nodes at the time of startup.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  }
                },
                "required": [
                  "servers"
                ],
                "type": [
                  "object",
                  "null"
                ]
              },
              "http": {
                "additionalProperties": false,
                "description": "out_http plugin",
                "properties": {
                  "auth": {
                    "additionalProperties": false,
                    "description": "Auth section for this plugin",
                    "properties": {
                      "auth": {
                        "description": "The method for HTTP authentication. Now only basic.",
                        "type": [
                          "string",
                          "null"
                        ]
                      },
                      "password": {
                        "additionalProperties": false,
                        "description": "The password for basic authentication.",
                        "properties": {
                          "valueFrom": {
                            "additionalProperties": false,
                            "description": "ValueSource defines how to find a value's key.",
                            "properties": {
                              "secretKeyRef": {
                                "additionalProperties": false,
                                "description": "Selects a key of a secret in the pod's namespace",
                                "properties": {
                                  "key": {
                                    "description": "The key of the secret to select from.  Must be a valid secret key.",
                                    "type": "string"
                                  },
                                  "name": {
                                    "default": "",
                                    "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                    "type": [
                                      "string",
                                      "null"
                                    ]
                                  },
                                  "optional": {
                                    "description": "Specify whether the Secret or its key must be defined",
                                    "type": [
                                      "boolean",
                                      "null"
                                    ]
                                  }
                                },
                                "required": [
                                  "key"
                                ],
                                "type": [
                                  "object",
                                  "null"
                                ],
                                "x-kubernetes-map-type": "atomic"
                              }
                            },
                            "type": [
                              "object",
                              "null"
                            ]
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      },
                      "username": {
                        "additionalProperties": false,
                        "description": "The username for basic authentication.",
                        "properties": {
                          "valueFrom": {
                            "additionalProperties": false,
                            "description": "ValueSource defines how to find a value's key.",
                            "properties": {
                              "secretKeyRef": {
                                "additionalProperties": false,
                                "description": "Selects a key of a secret in the pod's namespace",
                                "properties": {
                                  "key": {
                                    "description": "The key of the secret to select from.  Must be a valid secret key.",
                                    "type": "string"
                                  },
                                  "name": {
                                    "default": "",
                                    "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                    "type": [
                                      "string",
                                      "null"
                                    ]
                                  },
                                  "optional": {
                                    "description": "Specify whether the Secret or its key must be defined",
                                    "type": [
                                      "boolean",
                                      "null"
                                    ]
                                  }
                                },
                                "required": [
                                  "key"
                                ],
                                "type": [
                                  "object",
                                  "null"
                                ],
                                "x-kubernetes-map-type": "atomic"
                              }
                            },
                            "type": [
                              "object",
                              "null"
                            ]
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "compress": {
                    "description": "Compress enables the given compression method for HTTP requests.",
                    "enum": [
                      "text",
                      "gzip"
                    ],
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "contentType": {
                    "description": "ContentType defines Content-Type for HTTP request. out_http automatically set Content-Type for built-in formatters when this parameter is not specified.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "endpoint": {
                    "description": "Endpoint defines the endpoint for HTTP request. If you want to use HTTPS, use https prefix.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "errorResponseAsUnrecoverable": {
                    "description": "Raise UnrecoverableError when the response code is not SUCCESS.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "headers": {
                    "description": "Headers defines the additional headers for HTTP request.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "headersFromPlaceholders": {
                    "description": "Additional placeholder based headers for HTTP request. If you want to use tag or record field, use this parameter instead of headers.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "httpMethod": {
                    "description": "HttpMethod defines the method for HTTP request.",
                    "enum": [
                      "post",
                      "put"
                    ],
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "jsonArray": {
                    "description": "JsonArray defines whether to use the array format of JSON or not",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "openTimeout": {
                    "description": "OpenTimeout defines the connection open timeout in seconds.",
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "proxy": {
                    "description": "Proxy defines the proxy for HTTP request.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "readTimeout": {
                    "description": "ReadTimeout defines the read timeout in seconds.",
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "retryableResponseCodes": {
                    "description": "The list of retryable response codes. If the response code is included in this list, out_http retries the buffer flush.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "sslTimeout": {
                    "description": "SslTimeout defines the TLS timeout in seconds.",
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "tlsCaCertPath": {
                    "description": "TlsCaCertPath defines the CA certificate path for TLS.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "tlsCiphers": {
                    "description": "TlsCiphers defines the cipher suites configuration of TLS.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "tlsClientCertPath": {
                    "description": "TlsClientCertPath defines the client certificate path for TLS.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "tlsPrivateKeyPassphrase": {
                    "description": "TlsPrivateKeyPassphrase defines the client private key passphrase for TLS.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "tlsPrivateKeyPath": {
                    "description": "TlsPrivateKeyPath defines the client private key path for TLS.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "tlsVerifyMode": {
                    "description": "TlsVerifyMode defines the verify mode of TLS.",
                    "enum": [
                      "peer",
                      "none"
                    ],
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "tlsVersion": {
                    "description": "TlsVersion defines the default version of TLS transport.",
                    "enum": [
                      "TLSv1_1",
                      "TLSv1_2"
                    ],
                    "type": [
                      "string",
                      "null"
                    ]
                  }
                },
                "type": [
                  "object",
                  "null"
                ]
              },
              "inject": {
                "additionalProperties": false,
                "description": "inject section",
                "properties": {
                  "hostname": {
                    "description": "Hostname value",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "hostnameKey": {
                    "description": "The field name to inject hostname",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "inline": {
                    "additionalProperties": false,
                    "description": "Time section",
                    "properties": {
                      "localtime": {
                        "description": "If true, uses local time.",
                        "type": [
                          "boolean",
                          "null"
                        ]
                      },
                      "timeFormat": {
                        "description": "Process value according to the specified format. This is available only when time_type is string",
                        "type": [
                          "string",
                          "null"
                        ]
                      },
                      "timeFormatFallbacks": {
                        "description": "Uses the specified time format as a fallback in the specified order. You can parse undetermined time format by using time_format_fallbacks. This options is enabled when time_type is mixed.",
                        "type": [
                          "string",
                          "null"
                        ]
                      },
                      "timeType": {
                        "description": "parses/formats value according to this type, default is string",
                        "enum": [
                          "float",
                          "unixtime",
                          "string",
                          "mixed"
                        ],
                        "type": [
                          "string",
                          "null"
                        ]
                      },
                      "timezone": {
                        "description": "Uses the specified timezone.",
                        "type": [
                          "string",
                          "null"
                        ]
                      },
                      "utc": {
                        "description": "If true, uses UTC.",
                        "type": [
                          "boolean",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "tagKey": {
                    "description": "The field name to inject tag",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "timeKey": {
                    "description": "The field name to inject time",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "workerIdKey": {
                    "description": "The field name to inject worker_id",
                    "type": [
                      "string",
                      "null"
                    ]
                  }
                },
                "type": [
                  "object",
                  "null"
                ]
              },
              "kafka": {
                "additionalProperties": false,
                "description": "out_kafka plugin",
                "properties": {
                  "brokers": {
                    "description": "The list of all seed brokers, with their host and port information. Default: localhost:9092",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "compressionCodec": {
                    "description": "The codec the producer uses to compress messages (default: nil).",
                    "enum": [
                      "gzip",
                      "snappy"
                    ],
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "defaultTopic": {
                    "description": "The name of the default topic. (default: nil)",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "requiredAcks": {
                    "description": "The number of acks required per request.",
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "topicKey": {
                    "description": "The field name for the target topic. If the field value is app, this plugin writes events to the app topic.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "useEventTime": {
                    "description": "Set fluentd event time to Kafka's CreateTime.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  }
                },
                "type": [
                  "object",
                  "null"
                ]
              },
              "logLevel": {
                "description": "The @log_level parameter specifies the plugin-specific logging level",
                "type": [
                  "string",
                  "null"
                ]
              },
              "loki": {
                "additionalProperties": false,
                "description": "out_loki plugin",
                "properties": {
                  "bearerTokenFile": {
                    "description": "Set path to file with bearer authentication token\nCan be used as alterntative to HTTP basic authentication",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "dropSingleKey": {
                    "description": "If a record only has 1 key, then just set the log line to the value and discard the key.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "extractKubernetesLabels": {
                    "description": "If set to true, it will add all Kubernetes labels to the Stream labels.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "httpPassword": {
                    "additionalProperties": false,
                    "description": "Password for user defined in HTTP_User\nSet HTTP basic authentication password",
                    "properties": {
                      "valueFrom": {
                        "additionalProperties": false,
                        "description": "ValueSource defines how to find a value's key.",
                        "properties": {
                          "secretKeyRef": {
                            "additionalProperties": false,
                            "description": "Selects a key of a secret in the pod's namespace",
                            "properties": {
                              "key": {
                                "description": "The key of the secret to select from.  Must be a valid secret key.",
                                "type": "string"
                              },
                              "name": {
                                "default": "",
                                "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                "type": [
                                  "string",
                                  "null"
                                ]
                              },
                              "optional": {
                                "description": "Specify whether the Secret or its key must be defined",
                                "type": [
                                  "boolean",
                                  "null"
                                ]
                              }
                            },
                            "required": [
                              "key"
                            ],
                            "type": [
                              "object",
                              "null"
                            ],
                            "x-kubernetes-map-type": "atomic"
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "httpUser": {
                    "additionalProperties": false,
                    "description": "Set HTTP basic authentication user name.",
                    "properties": {
                      "valueFrom": {
                        "additionalProperties": false,
                        "description": "ValueSource defines how to find a value's key.",
                        "properties": {
                          "secretKeyRef": {
                            "additionalProperties": false,
                            "description": "Selects a key of a secret in the pod's namespace",
                            "properties": {
                              "key": {
                                "description": "The key of the secret to select from.  Must be a valid secret key.",
                                "type": "string"
                              },
                              "name": {
                                "default": "",
                                "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                "type": [
                                  "string",
                                  "null"
                                ]
                              },
                              "optional": {
                                "description": "Specify whether the Secret or its key must be defined",
                                "type": [
                                  "boolean",
                                  "null"
                                ]
                              }
                            },
                            "required": [
                              "key"
                            ],
                            "type": [
                              "object",
                              "null"
                            ],
                            "x-kubernetes-map-type": "atomic"
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "includeThreadLabel": {
                    "description": "Whether or not to include the fluentd_thread label when multiple threads are used for flushing",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "insecure": {
                    "description": "Disable certificate validation",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "labelKeys": {
                    "description": "Optional list of record keys that will be placed as stream labels.\nThis configuration property is for records key only.",
                    "items": {
                      "type": "string"
                    },
                    "type": [
                      "array",
                      "null"
                    ]
                  },
                  "labels": {
                    "description": "Stream labels for API request. It can be multiple comma separated of strings specifying  key=value pairs.\nIn addition to fixed parameters, it also allows to add custom record keys (similar to label_keys property).",
                    "items": {
                      "type": "string"
                    },
                    "type": [
                      "array",
                      "null"
                    ]
                  },
                  "lineFormat": {
                    "description": "Format to use when flattening the record to a log line. Valid values are json or key_value.\nIf set to json,  the log line sent to Loki will be the Fluentd record dumped as JSON.\nIf set to key_value, the log line will be each item in the record concatenated together (separated by a single space) in the format.",
                    "enum": [
                      "json",
                      "key_value"
                    ],
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "removeKeys": {
                    "description": "Optional list of record keys that will be removed from stream labels.\nThis configuration property is for records key only.",
                    "items": {
                      "type": "string"
                    },
                    "type": [
                      "array",
                      "null"
                    ]
                  },
                  "tenantID": {
                    "additionalProperties": false,
                    "description": "Tenant ID used by default to push logs to Loki.\nIf omitted or empty it assumes Loki is running in single-tenant mode and no X-Scope-OrgID header is sent.",
                    "properties": {
                      "valueFrom": {
                        "additionalProperties": false,
                        "description": "ValueSource defines how to find a value's key.",
                        "properties": {
                          "secretKeyRef": {
                            "additionalProperties": false,
                            "description": "Selects a key of a secret in the pod's namespace",
                            "properties": {
                              "key": {
                                "description": "The key of the secret to select from.  Must be a valid secret key.",
                                "type": "string"
                              },
                              "name": {
                                "default": "",
                                "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                "type": [
                                  "string",
                                  "null"
                                ]
                              },
                              "optional": {
                                "description": "Specify whether the Secret or its key must be defined",
                                "type": [
                                  "boolean",
                                  "null"
                                ]
                              }
                            },
                            "required": [
                              "key"
                            ],
                            "type": [
                              "object",
                              "null"
                            ],
                            "x-kubernetes-map-type": "atomic"
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "tlsCaCertFile": {
                    "description": "TlsCaCert defines the CA certificate file for TLS.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "tlsClientCertFile": {
                    "description": "TlsClientCert defines the client certificate file for TLS.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "tlsPrivateKeyFile": {
                    "description": "TlsPrivateKey defines the client private key file for TLS.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "url": {
                    "description": "Loki URL.",
                    "type": "string"
                  }
                },
                "required": [
                  "url"
                ],
                "type": [
                  "object",
                  "null"
                ]
              },
              "nullPlugin": {
                "additionalProperties": false,
                "description": "null plugin",
                "properties": {
                  "neverFlush": {
                    "description": "NeverFlush for testing to simulate the output plugin that never succeeds to flush.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  }
                },
                "type": [
                  "object",
                  "null"
                ]
              },
              "opensearch": {
                "additionalProperties": false,
                "description": "out_opensearch plugin",
                "properties": {
                  "applicationName": {
                    "description": "Optional, Specify the application name for the rollover index to be created (default: default)",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "bulkMessageRequestThreshold": {
                    "description": "Optional, Configure bulk_message_request_threshold splitting threshold size (default: -1 unlimited)",
                    "format": "int32",
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "caFile": {
                    "description": "Optional, Absolute path to CA certificate file",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "clientCert": {
                    "description": "Optional, Absolute path to client Certificate file",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "clientKey": {
                    "description": "Optional, Absolute path to client private Key file",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "clientKeyPassword": {
                    "additionalProperties": false,
                    "description": "Optional, password for ClientKey file",
                    "properties": {
                      "valueFrom": {
                        "additionalProperties": false,
                        "description": "ValueSource defines how to find a value's key.",
                        "properties": {
                          "secretKeyRef": {
                            "additionalProperties": false,
                            "description": "Selects a key of a secret in the pod's namespace",
                            "properties": {
                              "key": {
                                "description": "The key of the secret to select from.  Must be a valid secret key.",
                                "type": "string"
                              },
                              "name": {
                                "default": "",
                                "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                "type": [
                                  "string",
                                  "null"
                                ]
                              },
                              "optional": {
                                "description": "Specify whether the Secret or its key must be defined",
                                "type": [
                                  "boolean",
                                  "null"
                                ]
                              }
                            },
                            "required": [
                              "key"
                            ],
                            "type": [
                              "object",
                              "null"
                            ],
                            "x-kubernetes-map-type": "atomic"
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "compressionLevel": {
                    "description": "Optional, You can specify the compression level (default: no_compression). Options: no_compression, best_compression, best_speed, default_compression",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "contentType": {
                    "description": "Optional, With content_type application/x-ndjson, plugin adds application/x-ndjson as Content-Type (default: application/json)",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "customHeaders": {
                    "description": "Optional, Custom headers in Hash format",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "defaultOpensearchVersion": {
                    "description": "Optional, Default OpenSearch version (default: 1)",
                    "format": "int32",
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "emitErrorForMissingId": {
                    "description": "Optional, When write_operation is not index, setting this true will cause plugin to emit_error_event of records which do not include _id field (default: false)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "exceptionBackup": {
                    "description": "Optional, Backup chunk when ignore exception occurs (default: true)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "failOnDetectingOsVersionRetryExceed": {
                    "description": "Optional, Indicates whether to fail when max_retry_get_os_version is exceeded (default: true)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "failOnPuttingTemplateRetryExceed": {
                    "description": "Optional, Indicates whether to fail when max_retry_putting_template is exceeded (default: true)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "host": {
                    "description": "The hostname of your Opensearch node (default: localhost).",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "hosts": {
                    "description": "Hosts defines a list of hosts if you want to connect to more than one Openearch nodes",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "httpBackend": {
                    "description": "Optional, You can specify HTTP backend (default: excon). Options: excon, typhoeus",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "httpBackendExconNonblock": {
                    "description": "Optional, With http_backend_excon_nonblock false, plugin uses excon with nonblock=false (default: true)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "idKey": {
                    "description": "Optional, Record accessor syntax to specify the field to use as _id in OpenSearch",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "ignoreExceptions": {
                    "description": "Optional, List of exception classes to ignore",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "includeTagKey": {
                    "description": "Optional, Include tag key in record (default: false)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "indexDatePattern": {
                    "description": "Optional, Specify the index date pattern for creating a rollover index (default: now/d)",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "indexName": {
                    "description": "IndexName defines the placeholder syntax of Fluentd plugin API. See https://docs.fluentd.org/configuration/buffer-section.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "logOs400Reason": {
                    "description": "Optional, Enable logging of 400 reason without enabling debug log level (default: false)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "logstashFormat": {
                    "description": "If true, Fluentd uses the conventional index name format logstash-%Y.%m.%d (default: false). This option supersedes the index_name option.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "logstashPrefix": {
                    "description": "LogstashPrefix defines the logstash prefix index name to write events when logstash_format is true (default: logstash).",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "maxRetryGetOsVersion": {
                    "description": "Optional, You can specify times of retry obtaining OpenSearch version (default: 15)",
                    "format": "int32",
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "maxRetryPuttingTemplate": {
                    "description": "Optional, You can specify times of retry putting template (default: 10)",
                    "format": "int32",
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "password": {
                    "additionalProperties": false,
                    "description": "Optional, The login credentials to connect to Opensearch",
                    "properties": {
                      "valueFrom": {
                        "additionalProperties": false,
                        "description": "ValueSource defines how to find a value's key.",
                        "properties": {
                          "secretKeyRef": {
                            "additionalProperties": false,
                            "description": "Selects a key of a secret in the pod's namespace",
                            "properties": {
                              "key": {
                                "description": "The key of the secret to select from.  Must be a valid secret key.",
                                "type": "string"
                              },
                              "name": {
                                "default": "",
                                "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                "type": [
                                  "string",
                                  "null"
                                ]
                              },
                              "optional": {
                                "description": "Specify whether the Secret or its key must be defined",
                                "type": [
                                  "boolean",
                                  "null"
                                ]
                              }
                            },
                            "required": [
                              "key"
                            ],
                            "type": [
                              "object",
                              "null"
                            ],
                            "x-kubernetes-map-type": "atomic"
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "path": {
                    "description": "Path defines the REST API endpoint of Opensearch to post write requests (default: nil).",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "pipeline": {
                    "description": "Optional, Pipeline name",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "port": {
                    "description": "The port number of your Opensearch node (default: 9200).",
                    "format": "int32",
                    "maximum": 65535,
                    "minimum": 1,
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "preferOjSerializer": {
                    "description": "Optional, With default behavior, plugin uses Yajl as JSON encoder/decoder. Set to true to use Oj (default: false)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "reconnectOnError": {
                    "description": "Optional, Indicates that the plugin should reset connection on any error (reconnect on next send) (default: false)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "reloadAfter": {
                    "description": "Optional, When ReloadConnections true, this is the integer number of operations after which the plugin will reload the connections (default: 10000)",
                    "format": "int32",
                    "type": [
                      "integer",
                      "null"
                    ]
                  },
                  "reloadConnections": {
                    "description": "Optional, Automatically reload connection after 10000 documents (default: true)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "reloadOnFailure": {
                    "description": "Optional, Indicates that the opensearch-transport will try to reload the nodes addresses if there is a failure while making the request (default: false)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "removeKeys": {
                    "description": "Optional, Remove specified keys from the event record",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "removeKeysOnUpdate": {
                    "description": "Optional, Remove keys when record is being updated",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "requestTimeout": {
                    "description": "Optional, HTTP request timeout in seconds (default: 5s)",
                    "pattern": "^\\d+(s|m|h|d)$",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "scheme": {
                    "description": "Specify https if your Opensearch endpoint supports SSL (default: http).",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "selectorClassName": {
                    "description": "Optional, Provide a selector class name",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "snifferClassName": {
                    "description": "Optional, Provide a different sniffer class name",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "sslMaxVersion": {
                    "description": "Optional, Maximum SSL/TLS version",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "sslMinVersion": {
                    "description": "Optional, Minimum SSL/TLS version",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "sslVerify": {
                    "description": "Optional, Force certificate validation",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "sslVersion": {
                    "description": "Optional, You can specify SSL/TLS version (default: TLSv1_2)",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "suppressDocWrap": {
                    "description": "Optional, Suppress doc_wrap (default: false)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "suppressTypeName": {
                    "description": "Optional, Suppress '[types removal]' warnings on OpenSearch 2.x (default: true for OS2+)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "tagKey": {
                    "description": "Optional, Tag key name when include_tag_key is true (default: tag)",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "templateOverwrite": {
                    "description": "Optional, Always update the template, even if it already exists (default: false)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "useLegacyTemplate": {
                    "description": "Optional, Use legacy template or not (default: false for composable templates)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "user": {
                    "additionalProperties": false,
                    "description": "Optional, The login credentials to connect to Opensearch",
                    "properties": {
                      "valueFrom": {
                        "additionalProperties": false,
                        "description": "ValueSource defines how to find a value's key.",
                        "properties": {
                          "secretKeyRef": {
                            "additionalProperties": false,
                            "description": "Selects a key of a secret in the pod's namespace",
                            "properties": {
                              "key": {
                                "description": "The key of the secret to select from.  Must be a valid secret key.",
                                "type": "string"
                              },
                              "name": {
                                "default": "",
                                "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                "type": [
                                  "string",
                                  "null"
                                ]
                              },
                              "optional": {
                                "description": "Specify whether the Secret or its key must be defined",
                                "type": [
                                  "boolean",
                                  "null"
                                ]
                              }
                            },
                            "required": [
                              "key"
                            ],
                            "type": [
                              "object",
                              "null"
                            ],
                            "x-kubernetes-map-type": "atomic"
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "utcIndex": {
                    "description": "Optional, UTC index (default: false for local time)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "verifyOsVersionAtStartup": {
                    "description": "Optional, Validate OpenSearch version at startup (default: true)",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "writeOperation": {
                    "description": "Optional, The write operation (default: index). Options: index, create, update, upsert",
                    "type": [
                      "string",
                      "null"
                    ]
                  }
                },
                "type": [
                  "object",
                  "null"
                ]
              },
              "s3": {
                "additionalProperties": false,
                "description": "out_s3 plugin",
                "properties": {
                  "awsKeyId": {
                    "description": "The AWS access key id.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "awsKeyIdFromSecret": {
                    "additionalProperties": false,
                    "description": "The AWS access key id from Secrets.",
                    "properties": {
                      "valueFrom": {
                        "additionalProperties": false,
                        "description": "ValueSource defines how to find a value's key.",
                        "properties": {
                          "secretKeyRef": {
                            "additionalProperties": false,
                            "description": "Selects a key of a secret in the pod's namespace",
                            "properties": {
                              "key": {
                                "description": "The key of the secret to select from.  Must be a valid secret key.",
                                "type": "string"
                              },
                              "name": {
                                "default": "",
                                "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                "type": [
                                  "string",
                                  "null"
                                ]
                              },
                              "optional": {
                                "description": "Specify whether the Secret or its key must be defined",
                                "type": [
                                  "boolean",
                                  "null"
                                ]
                              }
                            },
                            "required": [
                              "key"
                            ],
                            "type": [
                              "object",
                              "null"
                            ],
                            "x-kubernetes-map-type": "atomic"
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "awsSecKey": {
                    "description": "The AWS secret key.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "awsSecKeyFromSecret": {
                    "additionalProperties": false,
                    "description": "The AWS secret key from Secrets.",
                    "properties": {
                      "valueFrom": {
                        "additionalProperties": false,
                        "description": "ValueSource defines how to find a value's key.",
                        "properties": {
                          "secretKeyRef": {
                            "additionalProperties": false,
                            "description": "Selects a key of a secret in the pod's namespace",
                            "properties": {
                              "key": {
                                "description": "The key of the secret to select from.  Must be a valid secret key.",
                                "type": "string"
                              },
                              "name": {
                                "default": "",
                                "description": "Name of the referent.\nThis field is effectively required, but due to backwards compatibility is\nallowed to be empty. Instances of this type with an empty value here are\nalmost certainly wrong.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                                "type": [
                                  "string",
                                  "null"
                                ]
                              },
                              "optional": {
                                "description": "Specify whether the Secret or its key must be defined",
                                "type": [
                                  "boolean",
                                  "null"
                                ]
                              }
                            },
                            "required": [
                              "key"
                            ],
                            "type": [
                              "object",
                              "null"
                            ],
                            "x-kubernetes-map-type": "atomic"
                          }
                        },
                        "type": [
                          "object",
                          "null"
                        ]
                      }
                    },
                    "type": [
                      "object",
                      "null"
                    ]
                  },
                  "forcePathStyle": {
                    "description": "This prevents AWS SDK from breaking endpoint URL",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "path": {
                    "description": "The path prefix of the files on S3.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "proxyUri": {
                    "description": "The proxy URL.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "s3Bucket": {
                    "description": "The Amazon S3 bucket name.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "s3Endpoint": {
                    "description": "The endpoint URL (like \"http://localhost:9000/\")",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "s3ObjectKeyFormat": {
                    "description": "The actual S3 path. This is interpolated to the actual path.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "s3Region": {
                    "description": "The Amazon S3 region name",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "sseCustomerAlgorithm": {
                    "description": "The AWS KMS enctyption algorithm.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "sseCustomerKey": {
                    "description": "The AWS KMS key.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "sseCustomerKeyMd5": {
                    "description": "The AWS KMS key MD5.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "ssekmsKeyId": {
                    "description": "The AWS KMS key ID.",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "sslVerifyPeer": {
                    "description": "Verify the SSL certificate of the endpoint.",
                    "type": [
                      "boolean",
                      "null"
                    ]
                  },
                  "storeAs": {
                    "description": "The compression type.",
                    "enum": [
                      "gzip",
                      "lzo",
                      "json",
                      "txt"
                    ],
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "timeSliceFormat": {
                    "description": "This timestamp is added to each file name",
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "useServerSideEncryption": {
                    "description": "the following parameters are for S3 kms https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html",
                    "type": [
                      "string",
                      "null"
                    ]
                  }
                },
                "type": [
                  "object",
                  "null"
                ]
              },
              "stdout": {
                "description": "out_stdout plugin",
                "type": [
                  "object",
                  "null"
                ]
              },
              "tag": {
                "description": "Which tag to be matched.",
                "type": [
                  "string",
                  "null"
                ]
              }
            },
            "type": "object"
          },
          "type": [
            "array",
            "null"
          ]
        }
      },
      "type": [
        "object",
        "null"
      ]
    },
    "status": {
      "description": "ClusterOutputStatus defines the observed state of ClusterOutput",
      "type": [
        "object",
        "null"
      ]
    }
  },
  "type": "object"
}