api

type Ack struct {
	Id        []byte                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Committed *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=committed,proto3" json:"committed,omitempty"`
	// contains filtered or unexported fields
}

type CloseStream struct {
	Events uint64 `protobuf:"varint,1,opt,name=events,proto3" json:"events,omitempty"`
	Topics uint64 `protobuf:"varint,2,opt,name=topics,proto3" json:"topics,omitempty"`
	Acks   uint64 `protobuf:"varint,3,opt,name=acks,proto3" json:"acks,omitempty"`
	Nacks  uint64 `protobuf:"varint,4,opt,name=nacks,proto3" json:"nacks,omitempty"`
	// contains filtered or unexported fields
}

type Compression struct {
	Algorithm Compression_Algorithm `protobuf:"varint,1,opt,name=algorithm,proto3,enum=ensign.v1beta1.Compression_Algorithm" json:"algorithm,omitempty"`
	Level     int64                 `protobuf:"varint,2,opt,name=level,proto3" json:"level,omitempty"`
	// contains filtered or unexported fields
}

type Compression_Algorithm int32

type ConsumerGroup struct {

	// Unique ID of the group and the project ID found in the API Key of the group.
	Id        []byte `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	ProjectId []byte `protobuf:"bytes,2,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
	// Optional name for the group for easier identification.
	Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	// The delivery semantic for handling concurrent reads by multiple consumers.
	// Default is "at most once", a fire-and-forget mode that is also used by Kafka.
	Delivery DeliverySemantic `protobuf:"varint,4,opt,name=delivery,proto3,enum=ensign.v1beta1.DeliverySemantic" json:"delivery,omitempty"`
	// Delivery timeout to wait for an ack if a delivery semantic requires it.
	// Defaults to 20 seconds.
	DeliveryTimeout *durationpb.Duration `protobuf:"bytes,5,opt,name=delivery_timeout,json=deliveryTimeout,proto3" json:"delivery_timeout,omitempty"`
	// A map of the topics consumed by the consumer group and their delivered offsets.
	TopicOffsets map[string]uint64 `` /* 187-byte string literal not displayed */
	// IDs of the consumers that have connected to the consumer group.
	Consumers [][]byte               `protobuf:"bytes,13,rep,name=consumers,proto3" json:"consumers,omitempty"`
	Created   *timestamppb.Timestamp `protobuf:"bytes,14,opt,name=created,proto3" json:"created,omitempty"`
	Modified  *timestamppb.Timestamp `protobuf:"bytes,15,opt,name=modified,proto3" json:"modified,omitempty"`
	// contains filtered or unexported fields
}

type Deduplication struct {
	Strategy Deduplication_Strategy       `protobuf:"varint,1,opt,name=strategy,proto3,enum=ensign.v1beta1.Deduplication_Strategy" json:"strategy,omitempty"`
	Offset   Deduplication_OffsetPosition `protobuf:"varint,2,opt,name=offset,proto3,enum=ensign.v1beta1.Deduplication_OffsetPosition" json:"offset,omitempty"`
	// Keys and fields for the KEY_GROUPED, UNIQUE_KEY, and UNIQUE_FIELD strategies.
	Keys   []string `protobuf:"bytes,3,rep,name=keys,proto3" json:"keys,omitempty"`
	Fields []string `protobuf:"bytes,4,rep,name=fields,proto3" json:"fields,omitempty"`
	// If overwrite_duplicate is true (default false) then the duplicate event is
	// completely overwritten by the original event including differences in metadata,
	// type, mimetype, and even the created timestamp (though the committed timestamp
	// and provenance information will remain the same). This policy can significantly
	// reduce data storage but may cause loss of data if the deduplication policy
	// changes (if false, deduplication attempts to preserve as much information as
	// possible in the case where the policy may change).
	OverwriteDuplicate bool `protobuf:"varint,5,opt,name=overwrite_duplicate,json=overwriteDuplicate,proto3" json:"overwrite_duplicate,omitempty"`
	// contains filtered or unexported fields
}

type Deduplication_OffsetPosition int32

type Deduplication_Strategy int32

type DeliverySemantic int32

type Encryption struct {
	PublicKeyId         string               `protobuf:"bytes,1,opt,name=public_key_id,json=publicKeyId,proto3" json:"public_key_id,omitempty"`
	EncryptionKey       []byte               `protobuf:"bytes,2,opt,name=encryption_key,json=encryptionKey,proto3" json:"encryption_key,omitempty"`
	HmacSecret          []byte               `protobuf:"bytes,3,opt,name=hmac_secret,json=hmacSecret,proto3" json:"hmac_secret,omitempty"`
	Signature           []byte               `protobuf:"bytes,4,opt,name=signature,proto3" json:"signature,omitempty"`
	SealingAlgorithm    Encryption_Algorithm `` /* 151-byte string literal not displayed */
	EncryptionAlgorithm Encryption_Algorithm `` /* 160-byte string literal not displayed */
	SignatureAlgorithm  Encryption_Algorithm `` /* 157-byte string literal not displayed */
	// contains filtered or unexported fields
}

type Encryption_Algorithm int32

type EnsignClient interface {
	// Both the Publish and Subscribe RPCs are bidirectional streaming to allow for acks
	// and nacks of events to be sent between Ensign and the client. The Publish stream
	// is opened and the client sends events and receives acks/nacks -- when the client
	// closes the publish stream, the server sends back information about the current
	// state of the topic. When the Subscribe stream is opened, the client must send an
	// open stream message with the subscription info before receiving events. Once it
	// receives events it must send back acks/nacks up the stream so that Ensign
	// advances the topic offset for the rest of the clients in the group.
	Publish(ctx context.Context, opts ...grpc.CallOption) (Ensign_PublishClient, error)
	Subscribe(ctx context.Context, opts ...grpc.CallOption) (Ensign_SubscribeClient, error)
	// EnSQL is a server-side streaming RPC that executes an query and returns a stream
	// of events as a result set back from the query. It terminates once all results
	// have been returned or the client terminates the stream.
	EnSQL(ctx context.Context, in *Query, opts ...grpc.CallOption) (Ensign_EnSQLClient, error)
	Explain(ctx context.Context, in *Query, opts ...grpc.CallOption) (*QueryExplanation, error)
	// This is a simple topic management interface. Right now we assume that topics are
	// immutable, therefore there is no update topic RPC call. There are two ways to
	// delete a topic - archiving it makes the topic readonly so that no events can be
	// published to it, but it can still be read. Destroying the topic deletes it and
	// removes all of its data, freeing up the topic name to be used again.
	ListTopics(ctx context.Context, in *PageInfo, opts ...grpc.CallOption) (*TopicsPage, error)
	CreateTopic(ctx context.Context, in *Topic, opts ...grpc.CallOption) (*Topic, error)
	RetrieveTopic(ctx context.Context, in *Topic, opts ...grpc.CallOption) (*Topic, error)
	DeleteTopic(ctx context.Context, in *TopicMod, opts ...grpc.CallOption) (*TopicStatus, error)
	TopicNames(ctx context.Context, in *PageInfo, opts ...grpc.CallOption) (*TopicNamesPage, error)
	TopicExists(ctx context.Context, in *TopicName, opts ...grpc.CallOption) (*TopicExistsInfo, error)
	// SetTopicPolicy allows users to specify topic management policies, setting the
	// topic into a pending mode while the update takes place. This is a patch endpoint
	// so if a policy is set to UNKNOWN it is ignored; only named policies initiate
	// changes on the topic. If the topic is already in the policy, a READY status is
	// returned, otherwise a PENDING status is returned while the topic updates.
	SetTopicPolicy(ctx context.Context, in *TopicPolicy, opts ...grpc.CallOption) (*TopicStatus, error)
	// Info provides statistics and metrics describing the state of a project
	Info(ctx context.Context, in *InfoRequest, opts ...grpc.CallOption) (*ProjectInfo, error)
	// Implements a client-side heartbeat that can also be used by monitoring tools.
	Status(ctx context.Context, in *HealthCheck, opts ...grpc.CallOption) (*ServiceState, error)
}

type EnsignServer interface {
	// Both the Publish and Subscribe RPCs are bidirectional streaming to allow for acks
	// and nacks of events to be sent between Ensign and the client. The Publish stream
	// is opened and the client sends events and receives acks/nacks -- when the client
	// closes the publish stream, the server sends back information about the current
	// state of the topic. When the Subscribe stream is opened, the client must send an
	// open stream message with the subscription info before receiving events. Once it
	// receives events it must send back acks/nacks up the stream so that Ensign
	// advances the topic offset for the rest of the clients in the group.
	Publish(Ensign_PublishServer) error
	Subscribe(Ensign_SubscribeServer) error
	// EnSQL is a server-side streaming RPC that executes an query and returns a stream
	// of events as a result set back from the query. It terminates once all results
	// have been returned or the client terminates the stream.
	EnSQL(*Query, Ensign_EnSQLServer) error
	Explain(context.Context, *Query) (*QueryExplanation, error)
	// This is a simple topic management interface. Right now we assume that topics are
	// immutable, therefore there is no update topic RPC call. There are two ways to
	// delete a topic - archiving it makes the topic readonly so that no events can be
	// published to it, but it can still be read. Destroying the topic deletes it and
	// removes all of its data, freeing up the topic name to be used again.
	ListTopics(context.Context, *PageInfo) (*TopicsPage, error)
	CreateTopic(context.Context, *Topic) (*Topic, error)
	RetrieveTopic(context.Context, *Topic) (*Topic, error)
	DeleteTopic(context.Context, *TopicMod) (*TopicStatus, error)
	TopicNames(context.Context, *PageInfo) (*TopicNamesPage, error)
	TopicExists(context.Context, *TopicName) (*TopicExistsInfo, error)
	// SetTopicPolicy allows users to specify topic management policies, setting the
	// topic into a pending mode while the update takes place. This is a patch endpoint
	// so if a policy is set to UNKNOWN it is ignored; only named policies initiate
	// changes on the topic. If the topic is already in the policy, a READY status is
	// returned, otherwise a PENDING status is returned while the topic updates.
	SetTopicPolicy(context.Context, *TopicPolicy) (*TopicStatus, error)
	// Info provides statistics and metrics describing the state of a project
	Info(context.Context, *InfoRequest) (*ProjectInfo, error)
	// Implements a client-side heartbeat that can also be used by monitoring tools.
	Status(context.Context, *HealthCheck) (*ServiceState, error)
	// contains filtered or unexported methods
}

type Ensign_EnSQLClient interface {
	Recv() (*EventWrapper, error)
	grpc.ClientStream
}

type Ensign_EnSQLServer interface {
	Send(*EventWrapper) error
	grpc.ServerStream
}

type Ensign_PublishClient interface {
	Send(*PublisherRequest) error
	Recv() (*PublisherReply, error)
	grpc.ClientStream
}

type Ensign_PublishServer interface {
	Send(*PublisherReply) error
	Recv() (*PublisherRequest, error)
	grpc.ServerStream
}

type Ensign_SubscribeClient interface {
	Send(*SubscribeRequest) error
	Recv() (*SubscribeReply, error)
	grpc.ClientStream
}

type Ensign_SubscribeServer interface {
	Send(*SubscribeReply) error
	Recv() (*SubscribeRequest, error)
	grpc.ServerStream
}

type Event struct {

	// The datagram for the event.
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	// User-defined key-value pairs that can be optionally added to the event.
	Metadata map[string]string `` /* 157-byte string literal not displayed */
	// The mimetype describes how to parse the event datagram.
	Mimetype v1beta11.MIME `protobuf:"varint,4,opt,name=mimetype,proto3,enum=mimetype.v1beta1.MIME" json:"mimetype,omitempty"`
	// Type defines the schema of he event datagram.
	Type *Type `protobuf:"bytes,5,opt,name=type,proto3" json:"type,omitempty"`
	// Timestamp that the event was created according to the client's clock.
	Created *timestamppb.Timestamp `protobuf:"bytes,15,opt,name=created,proto3" json:"created,omitempty"`
	// contains filtered or unexported fields
}

type EventContainer struct {

	// All events in a container must belong to the same topic.
	TopicId []byte `protobuf:"bytes,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	// The offsets of the events in the container.
	StartOffset uint64 `protobuf:"varint,2,opt,name=start_offset,json=startOffset,proto3" json:"start_offset,omitempty"`
	EndOffset   uint64 `protobuf:"varint,3,opt,name=end_offset,json=endOffset,proto3" json:"end_offset,omitempty"`
	// Mapping of an index to the epoch; it is assumed that all offsets following the
	// mapping share the epoch until the next epoch is specified.
	Epochs map[uint32]uint64 `` /* 155-byte string literal not displayed */
	// The event data, possibly encrypted and compressed. The raw data is an array of
	// serialized event-wrappers with duplicated data removed from the wrapper and moved
	// to the top-level of the container.
	Events []byte `protobuf:"bytes,5,opt,name=events,proto3" json:"events,omitempty"`
	// Encryption and compression information for deserializing event data.
	Encryption  *Encryption  `protobuf:"bytes,6,opt,name=encryption,proto3" json:"encryption,omitempty"`
	Compression *Compression `protobuf:"bytes,7,opt,name=compression,proto3" json:"compression,omitempty"`
	// De-duplication of event metadata by storing only the unique values and mapping
	// the index of each event to the specified metadata as an index in its array.
	Regions        []v1beta1.Region  `protobuf:"varint,8,rep,packed,name=regions,proto3,enum=region.v1beta1.Region" json:"regions,omitempty"`
	RegionIndex    map[uint32]uint32 `` /* 184-byte string literal not displayed */
	Publishers     []*Publisher      `protobuf:"bytes,10,rep,name=publishers,proto3" json:"publishers,omitempty"`
	PublisherIndex map[uint32]uint32 `` /* 194-byte string literal not displayed */
	Keys           [][]byte          `protobuf:"bytes,12,rep,name=keys,proto3" json:"keys,omitempty"`
	KeyIndex       map[uint32]uint32 `` /* 176-byte string literal not displayed */
	Shards         []uint64          `protobuf:"varint,14,rep,packed,name=shards,proto3" json:"shards,omitempty"`
	ShardIndex     map[uint32]uint32 `` /* 182-byte string literal not displayed */
	// Access timestamps for the container
	Created  *timestamppb.Timestamp `protobuf:"bytes,31,opt,name=created,proto3" json:"created,omitempty"`
	Modified *timestamppb.Timestamp `protobuf:"bytes,32,opt,name=modified,proto3" json:"modified,omitempty"`
	// contains filtered or unexported fields
}

type EventTypeInfo struct {
	Type          *Type                  `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	Mimetype      v1beta11.MIME          `protobuf:"varint,2,opt,name=mimetype,proto3,enum=mimetype.v1beta1.MIME" json:"mimetype,omitempty"`
	Events        uint64                 `protobuf:"varint,10,opt,name=events,proto3" json:"events,omitempty"`
	Duplicates    uint64                 `protobuf:"varint,11,opt,name=duplicates,proto3" json:"duplicates,omitempty"`
	DataSizeBytes uint64                 `protobuf:"varint,12,opt,name=data_size_bytes,json=dataSizeBytes,proto3" json:"data_size_bytes,omitempty"`
	Modified      *timestamppb.Timestamp `protobuf:"bytes,15,opt,name=modified,proto3" json:"modified,omitempty"`
	// contains filtered or unexported fields
}

type EventWrapper struct {

	// The event ID is an RLID that represents an ordered series of concurrent events.
	Id []byte `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// The topic ID the event should be published to.
	TopicId []byte `protobuf:"bytes,2,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	// Offset and epoch are related to guarantee total ordering through consensus.
	Offset uint64 `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"`
	Epoch  uint64 `protobuf:"varint,4,opt,name=epoch,proto3" json:"epoch,omitempty"`
	// Publisher and geography information about the provenance of the event.
	Region    v1beta1.Region `protobuf:"varint,5,opt,name=region,proto3,enum=region.v1beta1.Region" json:"region,omitempty"`
	Publisher *Publisher     `protobuf:"bytes,6,opt,name=publisher,proto3" json:"publisher,omitempty"`
	// Keys allow the event to be sharded across topics and must be part of the wrapper.
	// The shard specifies which shard the key was assigned to by the sharding strategy.
	Key   []byte `protobuf:"bytes,7,opt,name=key,proto3" json:"key,omitempty"`
	Shard uint64 `protobuf:"varint,8,opt,name=shard,proto3" json:"shard,omitempty"`
	// The event data should be a proto marshaled Event that is serialized at the client.
	Event []byte `protobuf:"bytes,9,opt,name=event,proto3" json:"event,omitempty"`
	// Events can be encrypted and compressed individually but more often are encrypted
	// and compressed in event containers. This allows parity with containers but also
	// enables end-to-end encryption of specific events.
	Encryption  *Encryption  `protobuf:"bytes,10,opt,name=encryption,proto3" json:"encryption,omitempty"`
	Compression *Compression `protobuf:"bytes,11,opt,name=compression,proto3" json:"compression,omitempty"`
	// Deduplication pointer; if this event wrapper is a duplicate then it should be
	// omitted from standard queries depending on the deduplication strategy of the
	// topic. The DuplicateID points to the event that contains the data referred to by
	// this duplicated event wrapper. A duplicate event wrapper will likely have all of
	// the metadata but no event data.
	IsDuplicate bool   `protobuf:"varint,12,opt,name=is_duplicate,json=isDuplicate,proto3" json:"is_duplicate,omitempty"`
	DuplicateId []byte `protobuf:"bytes,13,opt,name=duplicate_id,json=duplicateId,proto3" json:"duplicate_id,omitempty"`
	// The timestamp that the event was committed by the consensus protocol.
	Committed *timestamppb.Timestamp `protobuf:"bytes,15,opt,name=committed,proto3" json:"committed,omitempty"`
	// LocalID is an ID that must be unique to the publisher and is used to send acks
	// back to the publisher. This field should be solely managed by the SDK publisher.
	// The field is discarded before saving to disk and is not available to subscribers
	// or any time after the publish ack/nack has been sent back to the publisher.
	LocalId []byte `protobuf:"bytes,16,opt,name=local_id,json=localId,proto3" json:"local_id,omitempty"`
	// contains filtered or unexported fields
}

type HealthCheck struct {

	// The number of failed health checks that proceeded the current check.
	Attempts uint32 `protobuf:"varint,1,opt,name=attempts,proto3" json:"attempts,omitempty"`
	// The timestamp of the last health check, successful or otherwise.
	LastCheckedAt *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=last_checked_at,json=lastCheckedAt,proto3" json:"last_checked_at,omitempty"`
	// contains filtered or unexported fields
}

type InfoRequest struct {
	Topics [][]byte `protobuf:"bytes,1,rep,name=topics,proto3" json:"topics,omitempty"`
	// contains filtered or unexported fields
}

type Nack struct {
	Id    []byte    `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Code  Nack_Code `protobuf:"varint,2,opt,name=code,proto3,enum=ensign.v1beta1.Nack_Code" json:"code,omitempty"`
	Error string    `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"`
	// contains filtered or unexported fields
}

type Nack_Code int32

type Node struct {
	Id       string         `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Hostname string         `protobuf:"bytes,2,opt,name=hostname,proto3" json:"hostname,omitempty"`
	Quorum   uint64         `protobuf:"varint,3,opt,name=quorum,proto3" json:"quorum,omitempty"`
	Shard    uint64         `protobuf:"varint,4,opt,name=shard,proto3" json:"shard,omitempty"`
	Region   v1beta1.Region `protobuf:"varint,5,opt,name=region,proto3,enum=region.v1beta1.Region" json:"region,omitempty"`
	Url      string         `protobuf:"bytes,6,opt,name=url,proto3" json:"url,omitempty"`
	// contains filtered or unexported fields
}

type OpenStream struct {
	ClientId string   `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
	Topics   []string `protobuf:"bytes,2,rep,name=topics,proto3" json:"topics,omitempty"`
	// contains filtered or unexported fields
}

type PageInfo struct {
	PageSize      uint32 `protobuf:"varint,1,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	// contains filtered or unexported fields
}

type Parameter struct {

	// Types that are assignable to Value:
	//
	//	*Parameter_I
	//	*Parameter_D
	//	*Parameter_B
	//	*Parameter_Y
	//	*Parameter_S
	Value isParameter_Value `protobuf_oneof:"value"`
	Name  string            `protobuf:"bytes,6,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

type Parameter_B struct {
	B bool `protobuf:"varint,3,opt,name=b,proto3,oneof"`
}

type Parameter_D struct {
	D float64 `protobuf:"fixed64,2,opt,name=d,proto3,oneof"`
}

type Parameter_I struct {
	I int64 `protobuf:"zigzag64,1,opt,name=i,proto3,oneof"`
}

type Parameter_S struct {
	S string `protobuf:"bytes,5,opt,name=s,proto3,oneof"`
}

type Parameter_Y struct {
	Y []byte `protobuf:"bytes,4,opt,name=y,proto3,oneof"`
}

type Placement struct {
	Epoch    uint64           `protobuf:"varint,1,opt,name=epoch,proto3" json:"epoch,omitempty"`
	Sharding ShardingStrategy `protobuf:"varint,2,opt,name=sharding,proto3,enum=ensign.v1beta1.ShardingStrategy" json:"sharding,omitempty"`
	Regions  []v1beta1.Region `protobuf:"varint,3,rep,packed,name=regions,proto3,enum=region.v1beta1.Region" json:"regions,omitempty"`
	Nodes    []*Node          `protobuf:"bytes,4,rep,name=nodes,proto3" json:"nodes,omitempty"`
	// contains filtered or unexported fields
}

type ProjectInfo struct {
	ProjectId         []byte `protobuf:"bytes,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
	NumTopics         uint64 `protobuf:"varint,2,opt,name=num_topics,json=numTopics,proto3" json:"num_topics,omitempty"`
	NumReadonlyTopics uint64 `protobuf:"varint,3,opt,name=num_readonly_topics,json=numReadonlyTopics,proto3" json:"num_readonly_topics,omitempty"`
	// These are simply sums of the data in topics; however they may be prone to
	// overflow given a sufficiently sized project.
	Events        uint64       `protobuf:"varint,7,opt,name=events,proto3" json:"events,omitempty"`
	Duplicates    uint64       `protobuf:"varint,8,opt,name=duplicates,proto3" json:"duplicates,omitempty"`
	DataSizeBytes uint64       `protobuf:"varint,9,opt,name=data_size_bytes,json=dataSizeBytes,proto3" json:"data_size_bytes,omitempty"`
	Topics        []*TopicInfo `protobuf:"bytes,15,rep,name=topics,proto3" json:"topics,omitempty"`
	// contains filtered or unexported fields
}

type Publisher struct {
	PublisherId string `protobuf:"bytes,1,opt,name=publisher_id,json=publisherId,proto3" json:"publisher_id,omitempty"`
	Ipaddr      string `protobuf:"bytes,2,opt,name=ipaddr,proto3" json:"ipaddr,omitempty"`
	ClientId    string `protobuf:"bytes,3,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
	UserAgent   string `protobuf:"bytes,4,opt,name=user_agent,json=userAgent,proto3" json:"user_agent,omitempty"`
	// contains filtered or unexported fields
}

type PublisherReply struct {

	// Types that are assignable to Embed:
	//
	//	*PublisherReply_Ack
	//	*PublisherReply_Nack
	//	*PublisherReply_Ready
	//	*PublisherReply_CloseStream
	Embed isPublisherReply_Embed `protobuf_oneof:"embed"`
	// contains filtered or unexported fields
}

type PublisherReply_Ack struct {
	Ack *Ack `protobuf:"bytes,1,opt,name=ack,proto3,oneof"`
}

type PublisherReply_CloseStream struct {
	CloseStream *CloseStream `protobuf:"bytes,4,opt,name=close_stream,json=closeStream,proto3,oneof"`
}

type PublisherReply_Nack struct {
	Nack *Nack `protobuf:"bytes,2,opt,name=nack,proto3,oneof"`
}

type PublisherReply_Ready struct {
	Ready *StreamReady `protobuf:"bytes,3,opt,name=ready,proto3,oneof"`
}

type PublisherRequest struct {

	// Types that are assignable to Embed:
	//
	//	*PublisherRequest_Event
	//	*PublisherRequest_OpenStream
	Embed isPublisherRequest_Embed `protobuf_oneof:"embed"`
	// contains filtered or unexported fields
}

type PublisherRequest_Event struct {
	Event *EventWrapper `protobuf:"bytes,1,opt,name=event,proto3,oneof"`
}

type PublisherRequest_OpenStream struct {
	OpenStream *OpenStream `protobuf:"bytes,2,opt,name=open_stream,json=openStream,proto3,oneof"`
}

type Query struct {
	Query             string       `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"`
	Params            []*Parameter `protobuf:"bytes,2,rep,name=params,proto3" json:"params,omitempty"`
	IncludeDuplicates bool         `protobuf:"varint,3,opt,name=include_duplicates,json=includeDuplicates,proto3" json:"include_duplicates,omitempty"`
	// contains filtered or unexported fields
}

type QueryExplanation struct {
	// contains filtered or unexported fields
}

type ServiceState struct {

	// Current service status as defined by the recieving system. The system is obliged
	// to respond with the closest matching status in a best-effort fashion. Alerts will
	// be triggered on service status changes if the system does not respond and the
	// previous system state was not unknown.
	Status ServiceState_Status `protobuf:"varint,1,opt,name=status,proto3,enum=ensign.v1beta1.ServiceState_Status" json:"status,omitempty"`
	// The current version of the node running the Ensign service
	Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
	// How long the node has been up and running since it was last rebooted
	Uptime *durationpb.Duration `protobuf:"bytes,3,opt,name=uptime,proto3" json:"uptime,omitempty"`
	// Hint to the client when to check the health status again.
	NotBefore *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=not_before,json=notBefore,proto3" json:"not_before,omitempty"`
	NotAfter  *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=not_after,json=notAfter,proto3" json:"not_after,omitempty"`
	// contains filtered or unexported fields
}

type ServiceState_Status int32

type ShardingStrategy int32

type StreamReady struct {
	ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` // repeated back to the client for sanity
	ServerId string `protobuf:"bytes,2,opt,name=server_id,json=serverId,proto3" json:"server_id,omitempty"` // the node that the stream is conneced to
	// Maps the topic name to the topic ID (ULID bytes) that are available on this node.
	// TODO: handle topic redirects to other nodes.
	Topics map[string][]byte `` /* 153-byte string literal not displayed */
	// contains filtered or unexported fields
}

type SubscribeReply struct {

	// Types that are assignable to Embed:
	//
	//	*SubscribeReply_Event
	//	*SubscribeReply_Ready
	//	*SubscribeReply_CloseStream
	Embed isSubscribeReply_Embed `protobuf_oneof:"embed"`
	// contains filtered or unexported fields
}

type SubscribeReply_CloseStream struct {
	CloseStream *CloseStream `protobuf:"bytes,3,opt,name=close_stream,json=closeStream,proto3,oneof"`
}

type SubscribeReply_Event struct {
	Event *EventWrapper `protobuf:"bytes,1,opt,name=event,proto3,oneof"`
}

type SubscribeReply_Ready struct {
	Ready *StreamReady `protobuf:"bytes,2,opt,name=ready,proto3,oneof"`
}

type SubscribeRequest struct {

	// Types that are assignable to Embed:
	//
	//	*SubscribeRequest_Ack
	//	*SubscribeRequest_Nack
	//	*SubscribeRequest_Subscription
	Embed isSubscribeRequest_Embed `protobuf_oneof:"embed"`
	// contains filtered or unexported fields
}

type SubscribeRequest_Ack struct {
	Ack *Ack `protobuf:"bytes,1,opt,name=ack,proto3,oneof"`
}

type SubscribeRequest_Nack struct {
	Nack *Nack `protobuf:"bytes,2,opt,name=nack,proto3,oneof"`
}

type SubscribeRequest_Subscription struct {
	Subscription *Subscription `protobuf:"bytes,3,opt,name=subscription,proto3,oneof"`
}

type Subscription struct {
	ClientId string         `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
	Topics   []string       `protobuf:"bytes,2,rep,name=topics,proto3" json:"topics,omitempty"`
	Query    *Query         `protobuf:"bytes,3,opt,name=query,proto3" json:"query,omitempty"`
	Group    *ConsumerGroup `protobuf:"bytes,4,opt,name=group,proto3" json:"group,omitempty"`
	// contains filtered or unexported fields
}

type Topic struct {
	Id            []byte                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	ProjectId     []byte                 `protobuf:"bytes,2,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
	Name          string                 `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	Readonly      bool                   `protobuf:"varint,4,opt,name=readonly,proto3" json:"readonly,omitempty"`
	Offset        uint64                 `protobuf:"varint,5,opt,name=offset,proto3" json:"offset,omitempty"`
	Shards        uint32                 `protobuf:"varint,6,opt,name=shards,proto3" json:"shards,omitempty"`
	Status        TopicState             `protobuf:"varint,7,opt,name=status,proto3,enum=ensign.v1beta1.TopicState" json:"status,omitempty"`
	Deduplication *Deduplication         `protobuf:"bytes,11,opt,name=deduplication,proto3" json:"deduplication,omitempty"`
	Placements    []*Placement           `protobuf:"bytes,12,rep,name=placements,proto3" json:"placements,omitempty"`
	Types         []*Type                `protobuf:"bytes,13,rep,name=types,proto3" json:"types,omitempty"`
	Created       *timestamppb.Timestamp `protobuf:"bytes,14,opt,name=created,proto3" json:"created,omitempty"`
	Modified      *timestamppb.Timestamp `protobuf:"bytes,15,opt,name=modified,proto3" json:"modified,omitempty"`
	// contains filtered or unexported fields
}

type TopicExistsInfo struct {
	Query  string `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"`
	Exists bool   `protobuf:"varint,2,opt,name=exists,proto3" json:"exists,omitempty"`
	// contains filtered or unexported fields
}

type TopicInfo struct {
	TopicId   []byte `protobuf:"bytes,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	ProjectId []byte `protobuf:"bytes,2,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
	// The event offset id specifies the last event that was used to make the TopicInfo
	// determination (e.g. up to which event was the topic info recorded for). To reset
	// the topic info, simply set this to nil/empty and the topic info is recomputed.
	EventOffsetId []byte                 `protobuf:"bytes,3,opt,name=event_offset_id,json=eventOffsetId,proto3" json:"event_offset_id,omitempty"`
	Events        uint64                 `protobuf:"varint,7,opt,name=events,proto3" json:"events,omitempty"`
	Duplicates    uint64                 `protobuf:"varint,8,opt,name=duplicates,proto3" json:"duplicates,omitempty"`
	DataSizeBytes uint64                 `protobuf:"varint,9,opt,name=data_size_bytes,json=dataSizeBytes,proto3" json:"data_size_bytes,omitempty"`
	Types         []*EventTypeInfo       `protobuf:"bytes,14,rep,name=types,proto3" json:"types,omitempty"`
	Modified      *timestamppb.Timestamp `protobuf:"bytes,15,opt,name=modified,proto3" json:"modified,omitempty"`
	// contains filtered or unexported fields
}

type TopicMod struct {
	Id        string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Operation TopicMod_Operation `protobuf:"varint,2,opt,name=operation,proto3,enum=ensign.v1beta1.TopicMod_Operation" json:"operation,omitempty"`
	// contains filtered or unexported fields
}

type TopicMod_Operation int32

type TopicName struct {
	TopicId   string `protobuf:"bytes,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	ProjectId string `protobuf:"bytes,2,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
	Name      string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

type TopicNamesPage struct {
	TopicNames    []*TopicName `protobuf:"bytes,1,rep,name=topic_names,json=topicNames,proto3" json:"topic_names,omitempty"`
	NextPageToken string       `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	// contains filtered or unexported fields
}

type TopicPolicy struct {
	Id                  string           `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	DeduplicationPolicy *Deduplication   `protobuf:"bytes,2,opt,name=deduplication_policy,json=deduplicationPolicy,proto3" json:"deduplication_policy,omitempty"`
	ShardingStrategy    ShardingStrategy `` /* 147-byte string literal not displayed */
	// contains filtered or unexported fields
}