api

type ACLEntry = kafka.ACLEntry

type AlterTopicConfigs200JSONResponse AlterTopicConfigsResponse

type AlterTopicConfigs400JSONResponse struct{ BadRequestJSONResponse }

type AlterTopicConfigs401JSONResponse struct{ UnauthorizedJSONResponse }

type AlterTopicConfigs403JSONResponse struct{ ForbiddenJSONResponse }

type AlterTopicConfigs404JSONResponse struct{ NotFoundJSONResponse }

type AlterTopicConfigs502JSONResponse struct{ BadGatewayJSONResponse }

type AlterTopicConfigsJSONRequestBody = AlterTopicConfigsRequest

type AlterTopicConfigsParams struct {
	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type AlterTopicConfigsRequest = kafka.AlterTopicConfigsRequest

type AlterTopicConfigsRequestObject struct {
	Cluster Cluster `json:"cluster"`
	Topic   Topic   `json:"topic"`
	Params  AlterTopicConfigsParams
	Body    *AlterTopicConfigsJSONRequestBody
}

type AlterTopicConfigsResponse struct {
	Results []AlterTopicConfigsResult `json:"results"`
}

type AlterTopicConfigsResponseObject interface {
	VisitAlterTopicConfigsResponse(w http.ResponseWriter) error
}

type AlterTopicConfigsResult = kafka.AlterTopicConfigsResult

type BadGateway = Error

type BadGatewayJSONResponse Error

type BadRequest = Error

type BadRequestJSONResponse Error

type BrokerInfo = kafka.BrokerInfo

type BrokerIssue = kafka.BrokerIssue

type Capabilities = kafka.Capabilities

type CapabilitiesResponse struct {
	Capabilities Capabilities `json:"capabilities"`
	Cluster      string       `json:"cluster"`
}

type ChiServerOptions struct {
	BaseURL          string
	BaseRouter       chi.Router
	Middlewares      []MiddlewareFunc
	ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
}

type Cluster = string

type ClusterConfig = config.ClusterConfig

type ClusterInfo = kafka.ClusterInfo

type ConnectionErrorClass = connerr.Class

type ConsumeMessages200JSONResponse MessagesPage

type ConsumeMessages400JSONResponse struct{ BadRequestJSONResponse }

type ConsumeMessages401JSONResponse struct{ UnauthorizedJSONResponse }

type ConsumeMessages403JSONResponse struct{ ForbiddenJSONResponse }

type ConsumeMessages404JSONResponse struct{ NotFoundJSONResponse }

type ConsumeMessages502JSONResponse struct{ BadGatewayJSONResponse }

type ConsumeMessagesParams struct {
	// Partition Partition number; -1 = all partitions.
	Partition *PartitionQuery `form:"partition,omitempty" json:"partition,omitempty"`

	// Limit Page size. Values above 500 are clamped to 500.
	Limit *int `form:"limit,omitempty" json:"limit,omitempty"`

	// From Seek mode. `end` = newest records, `start` = oldest, `offset` = from `offset` (single partition) or `partition_offsets`; `from_ts_ms` / `to_ts_ms` narrow the range here too: the offset is lifted to the first record at or after `from_ts_ms`, and the page stops before `to_ts_ms`. `timestamp` = first record at or after `from_ts_ms`.
	From *ConsumeMessagesParamsFrom `form:"from,omitempty" json:"from,omitempty"`

	// Offset Required when `from=offset` and `partition_offsets` is not set.
	Offset *int64 `form:"offset,omitempty" json:"offset,omitempty"`

	// PartitionOffsets Per-partition seek offsets as `p:o,p:o` (max 1024 entries). Only valid with `from=offset`.
	PartitionOffsets *string `form:"partition_offsets,omitempty" json:"partition_offsets,omitempty"`

	// FromTsMs Optional inclusive lower timestamp bound in Unix milliseconds.
	FromTsMs *FromTsMsQuery `form:"from_ts_ms,omitempty" json:"from_ts_ms,omitempty"`

	// ToTsMs Optional exclusive upper timestamp bound in Unix milliseconds.
	ToTsMs *ToTsMsQuery `form:"to_ts_ms,omitempty" json:"to_ts_ms,omitempty"`

	// Cursor Opaque continuation token from a previous `next_cursor`.
	Cursor *string `form:"cursor,omitempty" json:"cursor,omitempty"`

	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type ConsumeMessagesParamsFrom string

type ConsumeMessagesRequestObject struct {
	Cluster Cluster `json:"cluster"`
	Topic   Topic   `json:"topic"`
	Params  ConsumeMessagesParams
}

type ConsumeMessagesResponseObject interface {
	VisitConsumeMessagesResponse(w http.ResponseWriter) error
}

type CopyMessages200TexteventStreamResponse struct {
	Body          io.Reader
	ContentLength int64
}

type CopyMessages400JSONResponse Error

type CopyMessages401JSONResponse struct{ UnauthorizedJSONResponse }

type CopyMessages403JSONResponse struct{ ForbiddenJSONResponse }

type CopyMessages428JSONResponse struct {
	ProdConfirmationRequiredJSONResponse
}

type CopyMessages429JSONResponse struct {
	Body    Error
	Headers CopyMessages429ResponseHeaders
}

type CopyMessages429ResponseHeaders struct {
	RetryAfter *int
}

type CopyMessages502JSONResponse struct{ BadGatewayJSONResponse }

type CopyMessagesJSONRequestBody = CopyRequest

type CopyMessagesParams struct {
	// XKafkitoConfirmProd Must be `true` when the target cluster is marked `is_prod`; the request is rejected with 428 otherwise. Send only after explicit user confirmation.
	XKafkitoConfirmProd *CopyMessagesParamsXKafkitoConfirmProd `json:"X-Kafkito-Confirm-Prod,omitempty"`

	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type CopyMessagesParamsXKafkitoConfirmProd string

type CopyMessagesRequestObject struct {
	Cluster Cluster `json:"cluster"`
	Topic   Topic   `json:"topic"`
	Params  CopyMessagesParams
	Body    *CopyMessagesJSONRequestBody
}

type CopyMessagesResponseObject interface {
	VisitCopyMessagesResponse(w http.ResponseWriter) error
}

type CopyProgressEvent struct {
	// Copied Records produced to the destination topic so far.
	Copied int64 `json:"copied"`

	// Done True on the final event only; omitted otherwise.
	Done *bool `json:"done,omitempty"`

	// Error Set on the final event when the job aborted. Omitted when empty. Errors after the stream opened still carry HTTP status 200. The text starts with `consume: ` (reading the source) or `produce: ` (writing to the destination), followed by a text that names no address, port or operating system detail: a Kafka error code with its description (for example `TOPIC_AUTHORIZATION_FAILED: ...`), `topic not found`, `partition not found`, `cancelled`, the message of the `private_cluster_address_blocked` error, or the fixed text of a `ConnectionErrorClass`. The server log has the full error.
	Error *string `json:"error,omitempty"`

	// Skipped Source records deliberately left out because they cannot be reproduced byte-for-byte (Schema-Registry-decoded, or masked values, keys or header values). Omitted while 0.
	Skipped *int64 `json:"skipped,omitempty"`
}

type CopyRequest struct {
	// DestCluster Name of a server-configured destination cluster. Mutually exclusive with `dest_cluster_config`.
	DestCluster *string `json:"dest_cluster,omitempty"`

	// DestClusterConfig Ad-hoc ("private") cluster definition supplied per request instead of from the server config — the same JSON the `X-Kafkito-Cluster` header carries (base64-encoded there). Broker and Schema Registry hosts are subject to the server's outbound-host (SSRF) policy. A definition that violates it or fails validation gets a 400 whose message names the field (a broker by its 1-based position) and a fixed reason, never the submitted value.
	DestClusterConfig *ClusterConfig `json:"dest_cluster_config,omitempty"`

	// DestTopic Destination topic. Must already exist.
	DestTopic string `json:"dest_topic"`

	// FromTsMs Inclusive lower bound on source record timestamps.
	FromTsMs *int64 `json:"from_ts_ms,omitempty"`

	// Limit Maximum number of records to copy. Absent = no limit.
	Limit *int64 `json:"limit,omitempty"`

	// Partition Single source partition. Absent = all partitions.
	Partition *int32 `json:"partition,omitempty"`

	// PreservePartition Produce each record to the same partition number it came from. Requires the destination topic to have at least as many partitions as the highest source partition, otherwise the request is rejected with 400.
	PreservePartition *bool `json:"preserve_partition,omitempty"`

	// ToTsMs Exclusive upper bound on source record timestamps. When omitted the server substitutes the job's start time, so a copy of a live topic terminates instead of tailing it forever.
	ToTsMs *int64 `json:"to_ts_ms,omitempty"`
}

type CountMessages200JSONResponse MessageCountResponse

type CountMessages400JSONResponse struct{ BadRequestJSONResponse }

type CountMessages401JSONResponse struct{ UnauthorizedJSONResponse }

type CountMessages403JSONResponse struct{ ForbiddenJSONResponse }

type CountMessages404JSONResponse struct{ NotFoundJSONResponse }

type CountMessages502JSONResponse struct{ BadGatewayJSONResponse }

type CountMessagesParams struct {
	// Partition Partition number; -1 = all partitions.
	Partition *PartitionQuery `form:"partition,omitempty" json:"partition,omitempty"`

	// FromTsMs Optional inclusive lower timestamp bound in Unix milliseconds.
	FromTsMs *FromTsMsQuery `form:"from_ts_ms,omitempty" json:"from_ts_ms,omitempty"`

	// ToTsMs Optional exclusive upper timestamp bound in Unix milliseconds.
	ToTsMs *ToTsMsQuery `form:"to_ts_ms,omitempty" json:"to_ts_ms,omitempty"`

	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type CountMessagesRequestObject struct {
	Cluster Cluster `json:"cluster"`
	Topic   Topic   `json:"topic"`
	Params  CountMessagesParams
}

type CountMessagesResponseObject interface {
	VisitCountMessagesResponse(w http.ResponseWriter) error
}

type CreateACLResponse struct {
	// Acl ACL binding. As a request body it is a create spec or a delete filter. Enum-like fields are parsed case-insensitively by franz-go (`kmsg`).
	Acl ACLEntry `json:"acl"`
	Ok  bool     `json:"ok"`
}

type CreateAcl201JSONResponse CreateACLResponse

type CreateAcl400JSONResponse struct{ BadRequestJSONResponse }

type CreateAcl401JSONResponse struct{ UnauthorizedJSONResponse }

type CreateAcl403JSONResponse struct{ ForbiddenJSONResponse }

type CreateAcl404JSONResponse struct{ NotFoundJSONResponse }

type CreateAcl502JSONResponse struct{ BadGatewayJSONResponse }

type CreateAclJSONRequestBody = ACLEntry

type CreateAclParams struct {
	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type CreateAclRequestObject struct {
	Cluster Cluster `json:"cluster"`
	Params  CreateAclParams
	Body    *CreateAclJSONRequestBody
}

type CreateAclResponseObject interface {
	VisitCreateAclResponse(w http.ResponseWriter) error
}

type CreateGroup200JSONResponse ResetOffsetsResponse

type CreateGroup400JSONResponse struct{ BadRequestJSONResponse }

type CreateGroup401JSONResponse struct{ UnauthorizedJSONResponse }

type CreateGroup403JSONResponse struct{ ForbiddenJSONResponse }

type CreateGroup404JSONResponse struct{ NotFoundJSONResponse }

type CreateGroup409JSONResponse Error

type CreateGroup502JSONResponse struct{ BadGatewayJSONResponse }

type CreateGroupJSONRequestBody = CreateGroupRequest

type CreateGroupParams struct {
	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type CreateGroupRequest = kafka.CreateGroupRequest

type CreateGroupRequestObject struct {
	Cluster Cluster `json:"cluster"`
	Params  CreateGroupParams
	Body    *CreateGroupJSONRequestBody
}

type CreateGroupResponseObject interface {
	VisitCreateGroupResponse(w http.ResponseWriter) error
}

type CreateTopic201JSONResponse CreatedResponse

type CreateTopic400JSONResponse struct{ BadRequestJSONResponse }

type CreateTopic401JSONResponse struct{ UnauthorizedJSONResponse }

type CreateTopic403JSONResponse struct{ ForbiddenJSONResponse }

type CreateTopic404JSONResponse struct{ NotFoundJSONResponse }

type CreateTopic502JSONResponse struct{ BadGatewayJSONResponse }

type CreateTopicJSONRequestBody = CreateTopicRequest

type CreateTopicParams struct {
	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type CreateTopicRequest = kafka.CreateTopicRequest

type CreateTopicRequestObject struct {
	Cluster Cluster `json:"cluster"`
	Params  CreateTopicParams
	Body    *CreateTopicJSONRequestBody
}

type CreateTopicResponseObject interface {
	VisitCreateTopicResponse(w http.ResponseWriter) error
}

type CreatedResponse struct {
	Created string `json:"created"`
}

type DeleteACLResponse struct {
	// Deleted Number of deleted ACL bindings.
	Deleted int  `json:"deleted"`
	Ok      bool `json:"ok"`
}

type DeleteAcl200JSONResponse DeleteACLResponse

type DeleteAcl400JSONResponse struct{ BadRequestJSONResponse }

type DeleteAcl401JSONResponse struct{ UnauthorizedJSONResponse }

type DeleteAcl403JSONResponse struct{ ForbiddenJSONResponse }

type DeleteAcl404JSONResponse struct{ NotFoundJSONResponse }

type DeleteAcl502JSONResponse struct{ BadGatewayJSONResponse }

type DeleteAclJSONRequestBody = ACLEntry

type DeleteAclParams struct {
	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type DeleteAclRequestObject struct {
	Cluster Cluster `json:"cluster"`
	Params  DeleteAclParams
	Body    *DeleteAclJSONRequestBody
}

type DeleteAclResponseObject interface {
	VisitDeleteAclResponse(w http.ResponseWriter) error
}

type DeleteGroup200JSONResponse DeletedNameResponse

type DeleteGroup400JSONResponse struct{ BadRequestJSONResponse }

type DeleteGroup401JSONResponse struct{ UnauthorizedJSONResponse }

type DeleteGroup403JSONResponse struct{ ForbiddenJSONResponse }

type DeleteGroup404JSONResponse struct{ NotFoundJSONResponse }

type DeleteGroup502JSONResponse struct{ BadGatewayJSONResponse }

type DeleteGroupParams struct {
	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type DeleteGroupRequestObject struct {
	Cluster Cluster `json:"cluster"`
	Group   Group   `json:"group"`
	Params  DeleteGroupParams
}

type DeleteGroupResponseObject interface {
	VisitDeleteGroupResponse(w http.ResponseWriter) error
}

type DeleteRecords200JSONResponse DeleteRecordsResponse

type DeleteRecords400JSONResponse struct{ BadRequestJSONResponse }

type DeleteRecords401JSONResponse struct{ UnauthorizedJSONResponse }

type DeleteRecords403JSONResponse struct{ ForbiddenJSONResponse }

type DeleteRecords404JSONResponse struct{ NotFoundJSONResponse }

type DeleteRecords428JSONResponse struct {
	ProdConfirmationRequiredJSONResponse
}

type DeleteRecords502JSONResponse struct{ BadGatewayJSONResponse }

type DeleteRecordsJSONRequestBody = DeleteRecordsRequest

type DeleteRecordsParams struct {
	// XKafkitoConfirmProd Must be `true` when the target cluster is marked `is_prod`; the request is rejected with 428 otherwise. Send only after explicit user confirmation.
	XKafkitoConfirmProd *DeleteRecordsParamsXKafkitoConfirmProd `json:"X-Kafkito-Confirm-Prod,omitempty"`

	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type DeleteRecordsParamsXKafkitoConfirmProd string

type DeleteRecordsRequest = kafka.DeleteRecordsRequest

type DeleteRecordsRequestObject struct {
	Cluster Cluster `json:"cluster"`
	Topic   Topic   `json:"topic"`
	Params  DeleteRecordsParams
	Body    *DeleteRecordsJSONRequestBody
}

type DeleteRecordsResponse struct {
	Results []DeleteRecordsResult `json:"results"`
}

type DeleteRecordsResponseObject interface {
	VisitDeleteRecordsResponse(w http.ResponseWriter) error
}

type DeleteRecordsResult = kafka.DeleteRecordsResult

type DeleteSCRAMUserResponse struct {
	// Deleted Number of mechanisms deleted.
	Deleted int    `json:"deleted"`
	Ok      bool   `json:"ok"`
	User    string `json:"user"`
}

type DeleteScramUser200JSONResponse DeleteSCRAMUserResponse

type DeleteScramUser400JSONResponse struct{ BadRequestJSONResponse }

type DeleteScramUser401JSONResponse struct{ UnauthorizedJSONResponse }

type DeleteScramUser403JSONResponse struct{ ForbiddenJSONResponse }

type DeleteScramUser404JSONResponse struct{ NotFoundJSONResponse }

type DeleteScramUser502JSONResponse struct{ BadGatewayJSONResponse }

type DeleteScramUserParams struct {
	// Mechanism Mechanism to delete. Omitted = both mechanisms are tried.
	Mechanism *DeleteScramUserParamsMechanism `form:"mechanism,omitempty" json:"mechanism,omitempty"`

	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type DeleteScramUserParamsMechanism string

type DeleteScramUserRequestObject struct {
	Cluster Cluster `json:"cluster"`
	User    string  `json:"user"`
	Params  DeleteScramUserParams
}

type DeleteScramUserResponseObject interface {
	VisitDeleteScramUserResponse(w http.ResponseWriter) error
}

type DeleteSubject200JSONResponse DeleteSubjectResponse

type DeleteSubject400JSONResponse struct{ BadRequestJSONResponse }

type DeleteSubject401JSONResponse struct{ UnauthorizedJSONResponse }

type DeleteSubject403JSONResponse struct{ ForbiddenJSONResponse }

type DeleteSubject404JSONResponse struct{ NotFoundJSONResponse }

type DeleteSubject502JSONResponse struct{ BadGatewayJSONResponse }

type DeleteSubjectParams struct {
	// Permanent `true` performs a hard delete. Only `true` and `false` are accepted.
	Permanent *bool `form:"permanent,omitempty" json:"permanent,omitempty"`

	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type DeleteSubjectRequestObject struct {
	Cluster Cluster `json:"cluster"`
	Subject Subject `json:"subject"`
	Params  DeleteSubjectParams
}

type DeleteSubjectResponse struct {
	Deleted   string `json:"deleted"`
	Permanent bool   `json:"permanent"`
	Versions  []int  `json:"versions"`
}

type DeleteSubjectResponseObject interface {
	VisitDeleteSubjectResponse(w http.ResponseWriter) error
}

type DeleteTopic200JSONResponse DeletedNameResponse

type DeleteTopic400JSONResponse struct{ BadRequestJSONResponse }

type DeleteTopic401JSONResponse struct{ UnauthorizedJSONResponse }

type DeleteTopic403JSONResponse struct{ ForbiddenJSONResponse }

type DeleteTopic404JSONResponse struct{ NotFoundJSONResponse }

type DeleteTopic428JSONResponse struct {
	ProdConfirmationRequiredJSONResponse
}

type DeleteTopic502JSONResponse struct{ BadGatewayJSONResponse }

type DeleteTopicParams struct {
	// XKafkitoConfirmProd Must be `true` when the target cluster is marked `is_prod`; the request is rejected with 428 otherwise. Send only after explicit user confirmation.
	XKafkitoConfirmProd *DeleteTopicParamsXKafkitoConfirmProd `json:"X-Kafkito-Confirm-Prod,omitempty"`

	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type DeleteTopicParamsXKafkitoConfirmProd string

type DeleteTopicRequestObject struct {
	Cluster Cluster `json:"cluster"`
	Topic   Topic   `json:"topic"`
	Params  DeleteTopicParams
}

type DeleteTopicResponseObject interface {
	VisitDeleteTopicResponse(w http.ResponseWriter) error
}

type DeletedNameResponse struct {
	Deleted string `json:"deleted"`
}

type DescribeGroup200JSONResponse GroupDetail

type DescribeGroup400JSONResponse struct{ BadRequestJSONResponse }

type DescribeGroup401JSONResponse struct{ UnauthorizedJSONResponse }

type DescribeGroup403JSONResponse struct{ ForbiddenJSONResponse }

type DescribeGroup404JSONResponse struct{ NotFoundJSONResponse }

type DescribeGroup502JSONResponse struct{ BadGatewayJSONResponse }

type DescribeGroupParams struct {
	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type DescribeGroupRequestObject struct {
	Cluster Cluster `json:"cluster"`
	Group   Group   `json:"group"`
	Params  DescribeGroupParams
}

type DescribeGroupResponseObject interface {
	VisitDescribeGroupResponse(w http.ResponseWriter) error
}

type DescribeTopic200JSONResponse DescribeTopicResponse

type DescribeTopic400JSONResponse struct{ BadRequestJSONResponse }

type DescribeTopic401JSONResponse struct{ UnauthorizedJSONResponse }

type DescribeTopic403JSONResponse struct{ ForbiddenJSONResponse }

type DescribeTopic404JSONResponse struct{ NotFoundJSONResponse }

type DescribeTopic502JSONResponse struct{ BadGatewayJSONResponse }

type DescribeTopicParams struct {
	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type DescribeTopicRequestObject struct {
	Cluster Cluster `json:"cluster"`
	Topic   Topic   `json:"topic"`
	Params  DescribeTopicParams
}

type DescribeTopicResponse struct {
	Cluster string      `json:"cluster"`
	Topic   TopicDetail `json:"topic"`
}

type DescribeTopicResponseObject interface {
	VisitDescribeTopicResponse(w http.ResponseWriter) error
}

type DownloadMessageRaw200ApplicationoctetStreamResponse struct {
	Body          io.Reader
	Headers       DownloadMessageRaw200ResponseHeaders
	ContentLength int64
}

type DownloadMessageRaw200ApplicationxmlResponse struct {
	Body          io.Reader
	Headers       DownloadMessageRaw200ResponseHeaders
	ContentLength int64
}

type DownloadMessageRaw200JSONResponse struct {
	Body    openapi_types.File
	Headers DownloadMessageRaw200ResponseHeaders
}

type DownloadMessageRaw200ResponseHeaders struct {
	ContentDisposition   *string
	XKafkitoValueDecoded *string
}

type DownloadMessageRaw200TextResponse struct {
	Body    openapi_types.File
	Headers DownloadMessageRaw200ResponseHeaders
}

type DownloadMessageRaw400JSONResponse struct{ BadRequestJSONResponse }

type DownloadMessageRaw401JSONResponse struct{ UnauthorizedJSONResponse }

type DownloadMessageRaw403JSONResponse Error

type DownloadMessageRaw404JSONResponse struct{ NotFoundJSONResponse }

type DownloadMessageRaw413JSONResponse struct{ PayloadTooLargeJSONResponse }

type DownloadMessageRaw502JSONResponse struct{ BadGatewayJSONResponse }

type DownloadMessageRawParams struct {
	// Decoded `false` serves the value bytes as stored in Kafka instead of the Schema Registry decoded JSON. Only `true` and `false` are accepted.
	Decoded *bool `form:"decoded,omitempty" json:"decoded,omitempty"`

	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type DownloadMessageRawRequestObject struct {
	Cluster   Cluster `json:"cluster"`
	Topic     Topic   `json:"topic"`
	Partition int32   `json:"partition"`
	Offset    int64   `json:"offset"`
	Params    DownloadMessageRawParams
}

type DownloadMessageRawResponseObject interface {
	VisitDownloadMessageRawResponse(w http.ResponseWriter) error
}

type Error struct {
	// Action RBAC-denied action (403 only).
	Action *string `json:"action,omitempty"`

	// Code Machine-readable code where one exists, e.g. `kafka_upstream`, `private_cluster_address_blocked`, `private_clusters_disabled`, `private_clusters_forbidden`, `plain_without_tls`, `production_confirmation_required`, `copy_concurrency_limit`, `rate_limited`, `kafka_message_too_large`, `kafka_not_authorized`, `rbac_denied`, `topic_consumers_timeout`, `value_masked`, `invalid_request` (the request does not match this document; `error` names the parameter or body field and the violated rule, never the submitted value).
	Code *string `json:"code,omitempty"`

	// Error Human-readable message (`unauthorized`, `forbidden`, `not found`, ...).
	Error string `json:"error"`

	// Message Detail for 401 responses from the auth middleware.
	Message *string `json:"message,omitempty"`

	// Resource RBAC-denied resource as `<type>:<name>` (403 only).
	Resource *string `json:"resource,omitempty"`
}

type Forbidden = Error

type ForbiddenJSONResponse Error

type FromTsMsQuery = int64

type GetCapabilities200JSONResponse CapabilitiesResponse

type GetCapabilities400JSONResponse struct{ BadRequestJSONResponse }

type GetCapabilities401JSONResponse struct{ UnauthorizedJSONResponse }

type GetCapabilities403JSONResponse struct{ ForbiddenJSONResponse }

type GetCapabilities404JSONResponse struct{ NotFoundJSONResponse }

type GetCapabilities502JSONResponse struct{ BadGatewayJSONResponse }

type GetCapabilitiesParams struct {
	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type GetCapabilitiesRequestObject struct {
	Cluster Cluster `json:"cluster"`
	Params  GetCapabilitiesParams
}

type GetCapabilitiesResponseObject interface {
	VisitGetCapabilitiesResponse(w http.ResponseWriter) error
}

type GetHealth200JSONResponse HealthResponse

type GetHealthRequestObject struct {
}

type GetHealthResponseObject interface {
	VisitGetHealthResponse(w http.ResponseWriter) error
}

type GetInfo200JSONResponse InfoResponse

type GetInfo401JSONResponse struct{ UnauthorizedJSONResponse }

type GetInfoRequestObject struct {
}

type GetInfoResponseObject interface {
	VisitGetInfoResponse(w http.ResponseWriter) error
}

type GetMe200JSONResponse MeResponse

type GetMe401JSONResponse struct{ UnauthorizedJSONResponse }

type GetMeRequestObject struct {
}

type GetMeResponseObject interface {
	VisitGetMeResponse(w http.ResponseWriter) error
}

type GetMessageTimeline200JSONResponse MessageTimelineResponse

type GetMessageTimeline400JSONResponse struct{ BadRequestJSONResponse }

type GetMessageTimeline401JSONResponse struct{ UnauthorizedJSONResponse }

type GetMessageTimeline403JSONResponse struct{ ForbiddenJSONResponse }

type GetMessageTimeline404JSONResponse struct{ NotFoundJSONResponse }

type GetMessageTimeline502JSONResponse struct{ BadGatewayJSONResponse }

type GetMessageTimelineParams struct {
	// Partition Partition number; -1 = all partitions.
	Partition *PartitionQuery `form:"partition,omitempty" json:"partition,omitempty"`

	// FromTsMs Inclusive lower timestamp bound in Unix milliseconds.
	FromTsMs int64 `form:"from_ts_ms" json:"from_ts_ms"`

	// ToTsMs Exclusive upper timestamp bound in Unix milliseconds. Must be greater than `from_ts_ms`.
	ToTsMs int64 `form:"to_ts_ms" json:"to_ts_ms"`

	// SlotMs Time-slot width in milliseconds (e.g. 3600000 for hourly, 86400000 for daily).
	SlotMs int64 `form:"slot_ms" json:"slot_ms"`

	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type GetMessageTimelineRequestObject struct {
	Cluster Cluster `json:"cluster"`
	Topic   Topic   `json:"topic"`
	Params  GetMessageTimelineParams
}

type GetMessageTimelineResponseObject interface {
	VisitGetMessageTimelineResponse(w http.ResponseWriter) error
}

type GetOpenApiSpec200ApplicationyamlResponse struct {
	Body          io.Reader
	ContentLength int64
}

type GetOpenApiSpec401JSONResponse struct{ UnauthorizedJSONResponse }

type GetOpenApiSpecRequestObject struct {
}

type GetOpenApiSpecResponseObject interface {
	VisitGetOpenApiSpecResponse(w http.ResponseWriter) error
}

type GetReadiness200JSONResponse ReadinessResponse

type GetReadiness503JSONResponse ReadinessResponse

type GetReadinessRequestObject struct {
}

type GetReadinessResponseObject interface {
	VisitGetReadinessResponse(w http.ResponseWriter) error
}

type GetSchemaVersion200JSONResponse SchemaVersion

type GetSchemaVersion400JSONResponse struct{ BadRequestJSONResponse }

type GetSchemaVersion401JSONResponse struct{ UnauthorizedJSONResponse }

type GetSchemaVersion403JSONResponse struct{ ForbiddenJSONResponse }

type GetSchemaVersion404JSONResponse struct{ NotFoundJSONResponse }

type GetSchemaVersion502JSONResponse struct{ BadGatewayJSONResponse }

type GetSchemaVersionParams struct {
	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type GetSchemaVersionRequestObject struct {
	Cluster Cluster `json:"cluster"`
	Subject Subject `json:"subject"`
	Version string  `json:"version"`
	Params  GetSchemaVersionParams
}

type GetSchemaVersionResponseObject interface {
	VisitGetSchemaVersionResponse(w http.ResponseWriter) error
}

type Group = string

type GroupDetail = kafka.GroupDetail

type GroupInfo = kafka.GroupInfo

type GroupMember struct {
	Assignments []MemberAssignment `json:"assignments"`
	ClientHost  string             `json:"client_host"`
	ClientId    string             `json:"client_id"`

	// InstanceId Static-membership group.instance.id, if configured.
	InstanceId *string `json:"instance_id,omitempty"`
	MemberId   string  `json:"member_id"`
}

type GroupOffset struct {
	// AssignedTo Current owner as `<client_id>@<host>`, absent during rebalance.
	AssignedTo *string `json:"assigned_to,omitempty"`
	Lag        int64   `json:"lag"`
	LogEnd     int64   `json:"log_end"`
	Metadata   *string `json:"metadata,omitempty"`
	Offset     int64   `json:"offset"`
	Partition  int32   `json:"partition"`
	Topic      string  `json:"topic"`
}

type HealthResponse struct {
	Status HealthResponseStatus `json:"status"`
}

type HealthResponseStatus string

type InfoResponse struct {
	Name    string `json:"name"`
	Version string `json:"version"`
}

type InvalidParamFormatError struct {
	ParamName string
	Err       error
}

type ListACLsResponse struct {
	Acls    []ACLEntry `json:"acls"`
	Cluster string     `json:"cluster"`
}

type ListAcls200JSONResponse ListACLsResponse

type ListAcls400JSONResponse struct{ BadRequestJSONResponse }

type ListAcls401JSONResponse struct{ UnauthorizedJSONResponse }

type ListAcls403JSONResponse struct{ ForbiddenJSONResponse }

type ListAcls404JSONResponse struct{ NotFoundJSONResponse }

type ListAcls502JSONResponse struct{ BadGatewayJSONResponse }

type ListAclsParams struct {
	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type ListAclsRequestObject struct {
	Cluster Cluster `json:"cluster"`
	Params  ListAclsParams
}

type ListAclsResponseObject interface {
	VisitListAclsResponse(w http.ResponseWriter) error
}

type ListBrokers200JSONResponse ListBrokersResponse

type ListBrokers400JSONResponse struct{ BadRequestJSONResponse }

type ListBrokers401JSONResponse struct{ UnauthorizedJSONResponse }

type ListBrokers403JSONResponse struct{ ForbiddenJSONResponse }

type ListBrokers404JSONResponse struct{ NotFoundJSONResponse }

type ListBrokers502JSONResponse struct{ BadGatewayJSONResponse }

type ListBrokersParams struct {
	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type ListBrokersRequestObject struct {
	Cluster Cluster `json:"cluster"`
	Params  ListBrokersParams
}

type ListBrokersResponse struct {
	Brokers []BrokerInfo `json:"brokers"`
	Cluster string       `json:"cluster"`
}

type ListBrokersResponseObject interface {
	VisitListBrokersResponse(w http.ResponseWriter) error
}

type ListClusters200JSONResponse ListClustersResponse

type ListClusters401JSONResponse struct{ UnauthorizedJSONResponse }

type ListClustersRequestObject struct {
}

type ListClustersResponse struct {
	Clusters []ClusterInfo `json:"clusters"`
}

type ListClustersResponseObject interface {
	VisitListClustersResponse(w http.ResponseWriter) error
}

type ListGroups200JSONResponse ListGroupsResponse

type ListGroups400JSONResponse struct{ BadRequestJSONResponse }

type ListGroups401JSONResponse struct{ UnauthorizedJSONResponse }

type ListGroups403JSONResponse struct{ ForbiddenJSONResponse }

type ListGroups404JSONResponse struct{ NotFoundJSONResponse }

type ListGroups502JSONResponse struct{ BadGatewayJSONResponse }

type ListGroupsParams struct {
	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type ListGroupsRequestObject struct {
	Cluster Cluster `json:"cluster"`
	Params  ListGroupsParams
}

type ListGroupsResponse struct {
	Cluster string      `json:"cluster"`
	Groups  []GroupInfo `json:"groups"`
}

type ListGroupsResponseObject interface {
	VisitListGroupsResponse(w http.ResponseWriter) error
}

type ListSCRAMUsersResponse struct {
	Cluster string      `json:"cluster"`
	Users   []SCRAMUser `json:"users"`
}

type ListSchemaVersions200JSONResponse ListSchemaVersionsResponse

type ListSchemaVersions400JSONResponse struct{ BadRequestJSONResponse }

type ListSchemaVersions401JSONResponse struct{ UnauthorizedJSONResponse }

type ListSchemaVersions403JSONResponse struct{ ForbiddenJSONResponse }

type ListSchemaVersions404JSONResponse struct{ NotFoundJSONResponse }

type ListSchemaVersions502JSONResponse struct{ BadGatewayJSONResponse }

type ListSchemaVersionsParams struct {
	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type ListSchemaVersionsRequestObject struct {
	Cluster Cluster `json:"cluster"`
	Subject Subject `json:"subject"`
	Params  ListSchemaVersionsParams
}

type ListSchemaVersionsResponse struct {
	Subject  string `json:"subject"`
	Versions []int  `json:"versions"`
}

type ListSchemaVersionsResponseObject interface {
	VisitListSchemaVersionsResponse(w http.ResponseWriter) error
}

type ListScramUsers200JSONResponse ListSCRAMUsersResponse

type ListScramUsers400JSONResponse struct{ BadRequestJSONResponse }

type ListScramUsers401JSONResponse struct{ UnauthorizedJSONResponse }

type ListScramUsers403JSONResponse struct{ ForbiddenJSONResponse }

type ListScramUsers404JSONResponse struct{ NotFoundJSONResponse }

type ListScramUsers502JSONResponse struct{ BadGatewayJSONResponse }

type ListScramUsersParams struct {
	// XKafkitoCluster Base64-encoded JSON `ClusterConfig` of a private (browser-stored) cluster, max 8 KiB decoded and at most 50 brokers. Honoured when the `{cluster}` path segment is `__private__` (required then). A malformed header or a definition that fails validation is rejected with 400; the message names the field and a fixed reason, a broker by its 1-based position, and never repeats a value from the header. SASL/PLAIN without TLS is rejected with 400 `plain_without_tls` unless the operator sets `private_clusters.allow_plain_without_tls`. When `private_clusters.mode` does not allow the caller private clusters, the header is never read: a `__private__` request gets 403 (`private_clusters_disabled` or `private_clusters_forbidden`), and any other request ignores it. On an allowed request kafkito's RBAC does not apply to the private cluster; the broker's ACLs do.
	XKafkitoCluster *PrivateClusterHeader `json:"X-Kafkito-Cluster,omitempty"`
}

type ListScramUsersRequestObject struct {
	Cluster Cluster `json:"cluster"`
	Params  ListScramUsersParams
}

type ListScramUsersResponseObject interface {
	VisitListScramUsersResponse(w http.ResponseWriter) error
}

type ListSubjects200JSONResponse ListSubjectsResponse

type ListSubjects400JSONResponse struct{ BadRequestJSONResponse }

type ListSubjects401JSONResponse struct{ UnauthorizedJSONResponse }