sqlite_remotev1

type Block struct {

	// Byte offset in the file divided by page_size.
	Index uint64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	// Exactly page_size bytes.
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	// contains filtered or unexported fields
}

type Challenge struct {

	// 32 random bytes. Valid for this login only.
	Nonce []byte `protobuf:"bytes,1,opt,name=nonce,proto3" json:"nonce,omitempty"`
	// The server's configured identifier, normally its public WebSocket URL, e.g. "wss://vfs.example/v1/ws". It is
	// part of the signed transcript. A client that compares it with the URL it connected to detects a challenge that
	// another server relays. Browsers do not expose TLS channel binding, so this is the only binding available.
	// sqlite-remote-vfs does not compare it; it expects a separate key for each server instead.
	ServerId string `protobuf:"bytes,2,opt,name=server_id,json=serverId,proto3" json:"server_id,omitempty"`
	// Deadline for the `Proof`, in milliseconds since the Unix epoch.
	ExpiresAtMs uint64 `protobuf:"varint,3,opt,name=expires_at_ms,json=expiresAtMs,proto3" json:"expires_at_ms,omitempty"`
	// contains filtered or unexported fields
}

type Changed struct {
	DbId string `protobuf:"bytes,1,opt,name=db_id,json=dbId,proto3" json:"db_id,omitempty"`
	// Version of the client's local copy. Must not be greater than the current version.
	FromVersion uint64 `protobuf:"varint,2,opt,name=from_version,json=fromVersion,proto3" json:"from_version,omitempty"`
	// contains filtered or unexported fields
}

type Changes struct {
	FromVersion uint64 `protobuf:"varint,1,opt,name=from_version,json=fromVersion,proto3" json:"from_version,omitempty"`
	// The current version.
	ToVersion uint64 `protobuf:"varint,2,opt,name=to_version,json=toVersion,proto3" json:"to_version,omitempty"`
	// Indexes of all blocks written by any commit after `from_version`, ascending and without duplicates.
	Blocks []uint64 `protobuf:"varint,3,rep,packed,name=blocks,proto3" json:"blocks,omitempty"`
	// False if the server's change log does not reach back to `from_version`, or the list does not fit in one frame.
	// `blocks` is then empty and the client has to discard its local copy.
	Complete bool `protobuf:"varint,4,opt,name=complete,proto3" json:"complete,omitempty"`
	// contains filtered or unexported fields
}

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

type ClientFrame struct {

	// Chosen by the client. Must be greater than 0. Every answer to the request carries the same id.
	RequestId uint64 `protobuf:"varint,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	// 14 is reserved for recovery after a server restore.
	//
	// Types that are valid to be assigned to Body:
	//
	//	*ClientFrame_Hello
	//	*ClientFrame_Open
	//	*ClientFrame_Fetch
	//	*ClientFrame_Commit
	//	*ClientFrame_Ping
	//	*ClientFrame_CloseDb
	//	*ClientFrame_Proof
	//	*ClientFrame_Delete
	//	*ClientFrame_Changed
	//	*ClientFrame_ClaimSlot
	//	*ClientFrame_DeleteSlot
	//	*ClientFrame_SetSlotLabel
	Body isClientFrame_Body `protobuf_oneof:"body"`
	// contains filtered or unexported fields
}

type ClientFrame_Changed struct {
	Changed *Changed `protobuf:"bytes,19,opt,name=changed,proto3,oneof"`
}

type ClientFrame_ClaimSlot struct {
	ClaimSlot *ClaimSlot `protobuf:"bytes,20,opt,name=claim_slot,json=claimSlot,proto3,oneof"`
}

type ClientFrame_CloseDb struct {
	CloseDb *CloseDb `protobuf:"bytes,16,opt,name=close_db,json=closeDb,proto3,oneof"`
}

type ClientFrame_Commit struct {
	Commit *Commit `protobuf:"bytes,13,opt,name=commit,proto3,oneof"`
}

type ClientFrame_Delete struct {
	Delete *Delete `protobuf:"bytes,18,opt,name=delete,proto3,oneof"`
}

type ClientFrame_DeleteSlot struct {
	DeleteSlot *DeleteSlot `protobuf:"bytes,21,opt,name=delete_slot,json=deleteSlot,proto3,oneof"`
}

type ClientFrame_Fetch struct {
	Fetch *Fetch `protobuf:"bytes,12,opt,name=fetch,proto3,oneof"`
}

type ClientFrame_Hello struct {
	Hello *Hello `protobuf:"bytes,10,opt,name=hello,proto3,oneof"`
}

type ClientFrame_Open struct {
	Open *Open `protobuf:"bytes,11,opt,name=open,proto3,oneof"`
}

type ClientFrame_Ping struct {
	Ping *Ping `protobuf:"bytes,15,opt,name=ping,proto3,oneof"`
}

type ClientFrame_Proof struct {
	Proof *Proof `protobuf:"bytes,17,opt,name=proof,proto3,oneof"`
}

type ClientFrame_SetSlotLabel struct {
	SetSlotLabel *SetSlotLabel `protobuf:"bytes,22,opt,name=set_slot_label,json=setSlotLabel,proto3,oneof"`
}

type CloseDb struct {
	DbId       string `protobuf:"bytes,1,opt,name=db_id,json=dbId,proto3" json:"db_id,omitempty"`
	LeaseEpoch uint64 `protobuf:"varint,2,opt,name=lease_epoch,json=leaseEpoch,proto3" json:"lease_epoch,omitempty"`
	// contains filtered or unexported fields
}

type Commit struct {
	DbId string `protobuf:"bytes,1,opt,name=db_id,json=dbId,proto3" json:"db_id,omitempty"`
	// 16 random bytes, the same in every part. Makes a repeated commit idempotent: if the last applied commit has this
	// id and the version is base_version + 1, the server answers with that version again.
	CommitId []byte `protobuf:"bytes,2,opt,name=commit_id,json=commitId,proto3" json:"commit_id,omitempty"`
	// Current lease epoch, otherwise ERROR_CODE_FENCED.
	LeaseEpoch uint64 `protobuf:"varint,3,opt,name=lease_epoch,json=leaseEpoch,proto3" json:"lease_epoch,omitempty"`
	// Version the commit is based on. Must be the current version, otherwise ERROR_CODE_VERSION_CONFLICT.
	BaseVersion uint64 `protobuf:"varint,4,opt,name=base_version,json=baseVersion,proto3" json:"base_version,omitempty"`
	// Length of the database file after the commit, in blocks. Blocks at or beyond it are removed.
	PageCount uint64   `protobuf:"varint,5,opt,name=page_count,json=pageCount,proto3" json:"page_count,omitempty"`
	Blocks    []*Block `protobuf:"bytes,6,rep,name=blocks,proto3" json:"blocks,omitempty"`
	// True if more parts of this commit follow.
	More bool `protobuf:"varint,7,opt,name=more,proto3" json:"more,omitempty"`
	// Number of this part within the commit, starting at 0. Part 0 starts a new commit and discards an incomplete one.
	// Every further part must directly follow the previous part and repeat its commit_id, lease_epoch, base_version
	// and page_count. Otherwise the server refuses it and discards the commit, so later parts cannot be applied on
	// their own. This keeps a commit atomic although the client sends all parts without waiting for answers.
	Part uint32 `protobuf:"varint,8,opt,name=part,proto3" json:"part,omitempty"`
	// contains filtered or unexported fields
}

type CommitAck struct {
	CommitId []byte `protobuf:"bytes,1,opt,name=commit_id,json=commitId,proto3" json:"commit_id,omitempty"`
	// Version after the commit.
	Version uint64 `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"`
	// contains filtered or unexported fields
}

type Delete struct {
	DbId string `protobuf:"bytes,1,opt,name=db_id,json=dbId,proto3" json:"db_id,omitempty"`
	// Deletes even if another instance holds a lease that has not expired. That instance receives `LeaseRevoked`.
	// Without it, the request fails with ERROR_CODE_LEASE_HELD in that case.
	Takeover bool `protobuf:"varint,2,opt,name=takeover,proto3" json:"takeover,omitempty"`
	// contains filtered or unexported fields
}

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

type Error struct {
	Code ErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=sqlite_remote.v1.ErrorCode" json:"code,omitempty"`
	// Human-readable reason. For ERROR_CODE_INTERNAL it contains no details.
	Detail string `protobuf:"bytes,2,opt,name=detail,proto3" json:"detail,omitempty"`
	// Current version of the database. Set with ERROR_CODE_VERSION_CONFLICT.
	CurrentVersion uint64 `protobuf:"varint,3,opt,name=current_version,json=currentVersion,proto3" json:"current_version,omitempty"`
	// Time the current lease was granted, in milliseconds since the Unix epoch. Set with ERROR_CODE_LEASE_HELD.
	LeaseHolderSinceMs uint64 `protobuf:"varint,4,opt,name=lease_holder_since_ms,json=leaseHolderSinceMs,proto3" json:"lease_holder_since_ms,omitempty"`
	// contains filtered or unexported fields
}

type ErrorCode int32

type Fetch struct {
	DbId string `protobuf:"bytes,1,opt,name=db_id,json=dbId,proto3" json:"db_id,omitempty"`
	// Must be the current version. Otherwise the request fails with ERROR_CODE_VERSION_CONFLICT.
	Version uint64 `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"`
	// One range: `count` blocks starting at `first_block`. Ignored if `ranges` is set.
	FirstBlock uint64 `protobuf:"varint,3,opt,name=first_block,json=firstBlock,proto3" json:"first_block,omitempty"`
	Count      uint64 `protobuf:"varint,4,opt,name=count,proto3" json:"count,omitempty"`
	// Several ranges, in ascending order and without overlap. At most 4096. Blocks that were never written are
	// returned as zeros.
	Ranges []*Range `protobuf:"bytes,5,rep,name=ranges,proto3" json:"ranges,omitempty"`
	// contains filtered or unexported fields
}

type Hello struct {

	// Protocol version of the client. The server rejects a version other than its own with ERROR_CODE_BAD_REQUEST.
	ProtocolVersion uint32 `protobuf:"varint,1,opt,name=protocol_version,json=protocolVersion,proto3" json:"protocol_version,omitempty"`
	// Id of the client instance, e.g. one browser tab or worker. 1 to 64 bytes. Usually random. A client that restarts
	// may use the same id again to take back its own lease without takeover, see `Open.takeover`. Two instances that run
	// at the same time must not use the same id.
	InstanceId []byte `protobuf:"bytes,2,opt,name=instance_id,json=instanceId,proto3" json:"instance_id,omitempty"`
	// Algorithm and public key of the client's key pair. The client proves possession of the private key with a
	// `Proof`. The server derives the subject from the public key. The subject determines which databases the
	// connection can access. A client has no other way to select a subject.
	SigAlg    SigAlg `protobuf:"varint,3,opt,name=sig_alg,json=sigAlg,proto3,enum=sqlite_remote.v1.SigAlg" json:"sig_alg,omitempty"`
	PublicKey []byte `protobuf:"bytes,4,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
	// Access token, for a server that admits only clients with one. A signed JWT whose `cnf` claim binds it to
	// `public_key`, so that it is useless without the private key. The server checks it before the `Challenge` and
	// rejects a missing, invalid or expired token, or one bound to another key, with ERROR_CODE_ACCESS_DENIED. A server
	// without such a requirement ignores the field. See `HelloOk.access_token_ttl_ms`.
	AccessToken string `protobuf:"bytes,5,opt,name=access_token,json=accessToken,proto3" json:"access_token,omitempty"` // 6 is reserved for a second signature algorithm.
	// contains filtered or unexported fields
}

type HelloOk struct {

	// Protocol version of the server.
	ProtocolVersion uint32 `protobuf:"varint,1,opt,name=protocol_version,json=protocolVersion,proto3" json:"protocol_version,omitempty"`
	// Largest frame the server accepts, in bytes. The client splits a commit into parts that fit.
	MaxFrameBytes uint32 `protobuf:"varint,2,opt,name=max_frame_bytes,json=maxFrameBytes,proto3" json:"max_frame_bytes,omitempty"`
	// Interval at which the client sends a `Ping` while it is otherwise idle, in milliseconds.
	PingIntervalMs uint32 `protobuf:"varint,3,opt,name=ping_interval_ms,json=pingIntervalMs,proto3" json:"ping_interval_ms,omitempty"`
	// Time after the last renewal from which another instance can acquire the lease without `takeover`, in
	// milliseconds. Commits and pings renew the lease.
	LeaseTtlMs uint32 `protobuf:"varint,4,opt,name=lease_ttl_ms,json=leaseTtlMs,proto3" json:"lease_ttl_ms,omitempty"`
	// Remaining lifetime of the access token in milliseconds, 0 without a token. Relative, so that the clocks of client
	// and server need not agree. The client reconnects with a new token before this time has passed, between two
	// requests. Shortly after it has passed, the server closes the connection at the next frame.
	AccessTokenTtlMs uint64 `protobuf:"varint,5,opt,name=access_token_ttl_ms,json=accessTokenTtlMs,proto3" json:"access_token_ttl_ms,omitempty"`
	// contains filtered or unexported fields
}

type LeaseRevoked struct {
	DbId          string `protobuf:"bytes,1,opt,name=db_id,json=dbId,proto3" json:"db_id,omitempty"`
	NewLeaseEpoch uint64 `protobuf:"varint,2,opt,name=new_lease_epoch,json=newLeaseEpoch,proto3" json:"new_lease_epoch,omitempty"`
	// contains filtered or unexported fields
}

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

type Open struct {

	// Name of the database within the subject. 1 to 128 bytes of UTF-8.
	DbId string `protobuf:"bytes,1,opt,name=db_id,json=dbId,proto3" json:"db_id,omitempty"`
	// Page size of a new database. For an existing database it must be 0 or equal to the database's page size.
	PageSize uint32 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// Creates the database if it does not exist or was deleted. Without it, such a database fails with
	// ERROR_CODE_NOT_FOUND.
	CreateIfMissing bool `protobuf:"varint,3,opt,name=create_if_missing,json=createIfMissing,proto3" json:"create_if_missing,omitempty"`
	// Acquires the lease even if another instance holds one that has not expired. Without it, the open fails with
	// ERROR_CODE_LEASE_HELD in that case. The instance that holds the lease, identified by `Hello.instance_id`, gets a
	// new lease without it: a client that restarted has lost its lease id and cannot resume. Its earlier lease is fenced.
	Takeover bool `protobuf:"varint,4,opt,name=takeover,proto3" json:"takeover,omitempty"`
	// Set only when reopening after a broken connection. Continues the previous lease instead of acquiring a new one.
	Resume *Resume `protobuf:"bytes,5,opt,name=resume,proto3" json:"resume,omitempty"`
	// contains filtered or unexported fields
}

type Opened struct {
	LeaseId []byte `protobuf:"bytes,1,opt,name=lease_id,json=leaseId,proto3" json:"lease_id,omitempty"`
	// Fencing token. Every new lease has a higher epoch. A `Commit` must carry the current epoch, otherwise it fails
	// with ERROR_CODE_FENCED.
	LeaseEpoch uint64 `protobuf:"varint,2,opt,name=lease_epoch,json=leaseEpoch,proto3" json:"lease_epoch,omitempty"`
	// Current version. Every applied commit and every deletion increases it by 1.
	Version  uint64 `protobuf:"varint,3,opt,name=version,proto3" json:"version,omitempty"`
	PageSize uint32 `protobuf:"varint,4,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// Length of the database file, in blocks.
	PageCount uint64 `protobuf:"varint,5,opt,name=page_count,json=pageCount,proto3" json:"page_count,omitempty"`
	// commit_id of the last applied commit. A client whose commit was not acknowledged compares it with its own
	// commit_id to find out whether the commit was applied.
	LastCommitId []byte `protobuf:"bytes,6,opt,name=last_commit_id,json=lastCommitId,proto3" json:"last_commit_id,omitempty"`
	// contains filtered or unexported fields
}

type Pages struct {

	// Index of the first block in this frame.
	FirstBlock uint64 `protobuf:"varint,1,opt,name=first_block,json=firstBlock,proto3" json:"first_block,omitempty"`
	// Consecutive blocks from `first_block`, each exactly page_size bytes.
	Blocks [][]byte `protobuf:"bytes,2,rep,name=blocks,proto3" json:"blocks,omitempty"`
	// True on the last frame of the answer.
	Last bool `protobuf:"varint,3,opt,name=last,proto3" json:"last,omitempty"`
	// contains filtered or unexported fields
}

type Ping struct {

	// Client clock in milliseconds. Returned unchanged in the `Pong`.
	ClientTimeMs uint64 `protobuf:"varint,1,opt,name=client_time_ms,json=clientTimeMs,proto3" json:"client_time_ms,omitempty"`
	// contains filtered or unexported fields
}

type Pong struct {
	ClientTimeMs uint64 `protobuf:"varint,1,opt,name=client_time_ms,json=clientTimeMs,proto3" json:"client_time_ms,omitempty"`
	// contains filtered or unexported fields
}

type Proof struct {
	Signature []byte `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"`
	// contains filtered or unexported fields
}

type Range struct {
	FirstBlock uint64 `protobuf:"varint,1,opt,name=first_block,json=firstBlock,proto3" json:"first_block,omitempty"`
	Count      uint64 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"`
	// contains filtered or unexported fields
}

type Resume struct {

	// lease_id and lease_epoch from the previous `Opened`. If the lease is no longer current, the open fails with
	// ERROR_CODE_FENCED.
	LeaseId    []byte `protobuf:"bytes,1,opt,name=lease_id,json=leaseId,proto3" json:"lease_id,omitempty"`
	LeaseEpoch uint64 `protobuf:"varint,2,opt,name=lease_epoch,json=leaseEpoch,proto3" json:"lease_epoch,omitempty"`
	// The last version the server acknowledged to this client.
	KnownVersion uint64 `protobuf:"varint,3,opt,name=known_version,json=knownVersion,proto3" json:"known_version,omitempty"`
	// commit_id of a commit that was sent but not acknowledged. Empty if there is none.
	PendingCommitId []byte `protobuf:"bytes,4,opt,name=pending_commit_id,json=pendingCommitId,proto3" json:"pending_commit_id,omitempty"`
	// contains filtered or unexported fields
}

type ServerFrame struct {

	// The request_id of the request this frame answers. 0 for a frame the server sends unprompted (`LeaseRevoked`).
	RequestId uint64 `protobuf:"varint,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	// Types that are valid to be assigned to Body:
	//
	//	*ServerFrame_HelloOk
	//	*ServerFrame_Opened
	//	*ServerFrame_Pages
	//	*ServerFrame_CommitAck
	//	*ServerFrame_Pong
	//	*ServerFrame_LeaseRevoked
	//	*ServerFrame_Error
	//	*ServerFrame_Ok
	//	*ServerFrame_Challenge
	//	*ServerFrame_Changes
	//	*ServerFrame_Slot
	Body isServerFrame_Body `protobuf_oneof:"body"`
	// contains filtered or unexported fields
}

type ServerFrame_Challenge struct {
	Challenge *Challenge `protobuf:"bytes,18,opt,name=challenge,proto3,oneof"`
}

type ServerFrame_Changes struct {
	Changes *Changes `protobuf:"bytes,19,opt,name=changes,proto3,oneof"`
}

type ServerFrame_CommitAck struct {
	CommitAck *CommitAck `protobuf:"bytes,13,opt,name=commit_ack,json=commitAck,proto3,oneof"`
}

type ServerFrame_Error struct {
	Error *Error `protobuf:"bytes,16,opt,name=error,proto3,oneof"`
}

type ServerFrame_HelloOk struct {
	HelloOk *HelloOk `protobuf:"bytes,10,opt,name=hello_ok,json=helloOk,proto3,oneof"`
}

type ServerFrame_LeaseRevoked struct {
	LeaseRevoked *LeaseRevoked `protobuf:"bytes,15,opt,name=lease_revoked,json=leaseRevoked,proto3,oneof"`
}

type ServerFrame_Ok struct {
	Ok *Ok `protobuf:"bytes,17,opt,name=ok,proto3,oneof"`
}

type ServerFrame_Opened struct {
	Opened *Opened `protobuf:"bytes,11,opt,name=opened,proto3,oneof"`
}

type ServerFrame_Pages struct {
	Pages *Pages `protobuf:"bytes,12,opt,name=pages,proto3,oneof"`
}

type ServerFrame_Pong struct {
	Pong *Pong `protobuf:"bytes,14,opt,name=pong,proto3,oneof"`
}

type ServerFrame_Slot struct {
	Slot *Slot `protobuf:"bytes,20,opt,name=slot,proto3,oneof"`
}

type SetSlotLabel struct {

	// At most 256 bytes. Empty clears the label.
	Label string `protobuf:"bytes,1,opt,name=label,proto3" json:"label,omitempty"`
	// contains filtered or unexported fields
}

type SigAlg int32

type Slot struct {
	Label string `protobuf:"bytes,1,opt,name=label,proto3" json:"label,omitempty"`
	// Time the slot passed to its current key, in milliseconds since the Unix epoch.
	ClaimedAtMs uint64 `protobuf:"varint,2,opt,name=claimed_at_ms,json=claimedAtMs,proto3" json:"claimed_at_ms,omitempty"`
	// Label of the slot before this claim, if another key held it. Empty if the slot was free or already held by this
	// key.
	ReplacedLabel string `protobuf:"bytes,3,opt,name=replaced_label,json=replacedLabel,proto3" json:"replaced_label,omitempty"`
	// contains filtered or unexported fields
}