keibidrop

type Attr struct {
	Dev              uint64 `protobuf:"varint,1,opt,name=dev,proto3" json:"dev,omitempty"`
	Ino              uint64 `protobuf:"varint,2,opt,name=ino,proto3" json:"ino,omitempty"`
	Mode             uint32 `protobuf:"varint,3,opt,name=mode,proto3" json:"mode,omitempty"`
	Size             int64  `protobuf:"varint,4,opt,name=size,proto3" json:"size,omitempty"`
	AccessTime       uint64 `protobuf:"varint,5,opt,name=accessTime,proto3" json:"accessTime,omitempty"`
	ModificationTime uint64 `protobuf:"varint,6,opt,name=modificationTime,proto3" json:"modificationTime,omitempty"`
	ChangeTime       uint64 `protobuf:"varint,7,opt,name=changeTime,proto3" json:"changeTime,omitempty"`
	BirthTime        uint64 `protobuf:"varint,8,opt,name=birthTime,proto3" json:"birthTime,omitempty"`
	Flags            uint32 `protobuf:"varint,9,opt,name=flags,proto3" json:"flags,omitempty"`
	// contains filtered or unexported fields
}

type BatchNotifyRequest struct {
	Notifications []*NotifyRequest `protobuf:"bytes,1,rep,name=notifications,proto3" json:"notifications,omitempty"` // Ordered: receiver processes sequentially.
	Seq           uint64           `protobuf:"varint,2,opt,name=seq,proto3" json:"seq,omitempty"`                    // Monotonic batch sequence for ordering.
	Timestamp     uint64           `protobuf:"varint,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`        // Sender's unix nano timestamp.
	// contains filtered or unexported fields
}

type BatchNotifyResponse struct {
	Status    string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	Processed uint32 `protobuf:"varint,2,opt,name=processed,proto3" json:"processed,omitempty"` // Number of notifications successfully processed.
	// contains filtered or unexported fields
}

type CloseRequest struct {
	Handle uint64 `protobuf:"varint,1,opt,name=handle,proto3" json:"handle,omitempty"`
	Path   string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	// contains filtered or unexported fields
}

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

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

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

type FsyncRequest struct {
	Handle uint64 `protobuf:"varint,1,opt,name=handle,proto3" json:"handle,omitempty"`
	Path   string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	// contains filtered or unexported fields
}

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

type GetChunkHashesRequest struct {
	Path      string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	ChunkSize uint64 `protobuf:"varint,2,opt,name=chunk_size,json=chunkSize,proto3" json:"chunk_size,omitempty"` // requester's chunk size in bytes; server hashes at this granularity
	FromChunk uint64 `protobuf:"varint,3,opt,name=from_chunk,json=fromChunk,proto3" json:"from_chunk,omitempty"` // first chunk index to return
	Count     uint64 `protobuf:"varint,4,opt,name=count,proto3" json:"count,omitempty"`                          // number of chunks; 0 means to EOF
	// contains filtered or unexported fields
}

type GetChunkHashesResponse struct {
	ChunkIndex uint64 `protobuf:"varint,1,opt,name=chunk_index,json=chunkIndex,proto3" json:"chunk_index,omitempty"`
	Hash       uint64 `protobuf:"varint,2,opt,name=hash,proto3" json:"hash,omitempty"` // xxh3-64 of bytes [chunk_index*chunk_size, min((chunk_index+1)*chunk_size, fileSize))
	// contains filtered or unexported fields
}

type HeartbeatRequest struct {
	Timestamp uint64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` // sender's unix nano timestamp
	Seq       uint64 `protobuf:"varint,2,opt,name=seq,proto3" json:"seq,omitempty"`             // monotonic sequence number
	// contains filtered or unexported fields
}

type HeartbeatResponse struct {
	Timestamp    uint64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`                           // responder's unix nano timestamp
	ReqTimestamp uint64 `protobuf:"varint,2,opt,name=req_timestamp,json=reqTimestamp,proto3" json:"req_timestamp,omitempty"` // echo of request timestamp (for RTT)
	Seq          uint64 `protobuf:"varint,3,opt,name=seq,proto3" json:"seq,omitempty"`                                       // echo of sequence number
	// contains filtered or unexported fields
}

type KeibiServiceClient interface {
	Open(ctx context.Context, in *OpenRequest, opts ...grpc.CallOption) (*OpenResponse, error)
	Write(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[WriteRequest, WriteResponse], error)
	Read(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[ReadRequest, ReadResponse], error)
	Fsync(ctx context.Context, in *FsyncRequest, opts ...grpc.CallOption) (*FsyncResponse, error)
	Close(ctx context.Context, in *CloseRequest, opts ...grpc.CallOption) (*CloseResponse, error)
	Notify(ctx context.Context, in *NotifyRequest, opts ...grpc.CallOption) (*NotifyResponse, error)
	BatchNotify(ctx context.Context, in *BatchNotifyRequest, opts ...grpc.CallOption) (*BatchNotifyResponse, error)
	// Push-based file streaming: client sends one request, server pushes
	// all chunks sequentially. No per-chunk round-trip overhead.
	StreamFile(ctx context.Context, in *StreamFileRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StreamFileResponse], error)
	// Per-chunk xxh3-64 fingerprints for partial re-fetch on edit.
	GetChunkHashes(ctx context.Context, in *GetChunkHashesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[GetChunkHashesResponse], error)
	Debug(ctx context.Context, in *DebugRequest, opts ...grpc.CallOption) (*DebugResponse, error)
	// Re-keying for forward secrecy during long sessions.
	Rekey(ctx context.Context, in *RekeyRequest, opts ...grpc.CallOption) (*RekeyResponse, error)
	// Connection health monitoring for auto-reconnection.
	Heartbeat(ctx context.Context, in *HeartbeatRequest, opts ...grpc.CallOption) (*HeartbeatResponse, error)
}

type KeibiServiceServer interface {
	Open(context.Context, *OpenRequest) (*OpenResponse, error)
	Write(grpc.ClientStreamingServer[WriteRequest, WriteResponse]) error
	Read(grpc.BidiStreamingServer[ReadRequest, ReadResponse]) error
	Fsync(context.Context, *FsyncRequest) (*FsyncResponse, error)
	Close(context.Context, *CloseRequest) (*CloseResponse, error)
	Notify(context.Context, *NotifyRequest) (*NotifyResponse, error)
	BatchNotify(context.Context, *BatchNotifyRequest) (*BatchNotifyResponse, error)
	// Push-based file streaming: client sends one request, server pushes
	// all chunks sequentially. No per-chunk round-trip overhead.
	StreamFile(*StreamFileRequest, grpc.ServerStreamingServer[StreamFileResponse]) error
	// Per-chunk xxh3-64 fingerprints for partial re-fetch on edit.
	GetChunkHashes(*GetChunkHashesRequest, grpc.ServerStreamingServer[GetChunkHashesResponse]) error
	Debug(context.Context, *DebugRequest) (*DebugResponse, error)
	// Re-keying for forward secrecy during long sessions.
	Rekey(context.Context, *RekeyRequest) (*RekeyResponse, error)
	// Connection health monitoring for auto-reconnection.
	Heartbeat(context.Context, *HeartbeatRequest) (*HeartbeatResponse, error)
	// contains filtered or unexported methods
}

type KeibiService_GetChunkHashesClient = grpc.ServerStreamingClient[GetChunkHashesResponse]

type KeibiService_GetChunkHashesServer = grpc.ServerStreamingServer[GetChunkHashesResponse]

type KeibiService_ReadClient = grpc.BidiStreamingClient[ReadRequest, ReadResponse]

type KeibiService_ReadServer = grpc.BidiStreamingServer[ReadRequest, ReadResponse]

type KeibiService_StreamFileClient = grpc.ServerStreamingClient[StreamFileResponse]

type KeibiService_StreamFileServer = grpc.ServerStreamingServer[StreamFileResponse]

type KeibiService_WriteClient = grpc.ClientStreamingClient[WriteRequest, WriteResponse]

type KeibiService_WriteServer = grpc.ClientStreamingServer[WriteRequest, WriteResponse]

type NotifyRequest struct {
	Type    NotifyType `protobuf:"varint,1,opt,name=type,proto3,enum=keibidrop.NotifyType" json:"type,omitempty"`
	Path    string     `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	Name    string     `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	Attr    *Attr      `protobuf:"bytes,4,opt,name=attr,proto3" json:"attr,omitempty"`
	OldPath string     `protobuf:"bytes,5,opt,name=old_path,json=oldPath,proto3" json:"old_path,omitempty"` // For RENAME operations: the source path.
	// The newest peer version (RemoteMtimeNs) the sender had accepted for this
	// file when its edit session started. The receiver preserves a conflict
	// copy exactly when base < the version it holds: the edit provably never
	// saw it. 0 = unknown: never preserve (plain last-writer-wins).
	BaseMtimeNs int64 `protobuf:"varint,6,opt,name=base_mtime_ns,json=baseMtimeNs,proto3" json:"base_mtime_ns,omitempty"`
	// contains filtered or unexported fields
}

type NotifyResponse struct {
	Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

type NotifyType int32

type OpenRequest struct {
	Path     string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	Create   bool   `protobuf:"varint,2,opt,name=create,proto3" json:"create,omitempty"`
	Truncate bool   `protobuf:"varint,3,opt,name=truncate,proto3" json:"truncate,omitempty"`
	// contains filtered or unexported fields
}

type OpenResponse struct {
	Handle uint64 `protobuf:"varint,1,opt,name=handle,proto3" json:"handle,omitempty"`
	// contains filtered or unexported fields
}

type ReadRequest struct {
	Handle     uint64 `protobuf:"varint,1,opt,name=handle,proto3" json:"handle,omitempty"`
	Path       string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	Offset     uint64 `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"`
	Size       uint32 `protobuf:"varint,4,opt,name=size,proto3" json:"size,omitempty"`
	Prefetch   bool   `protobuf:"varint,5,opt,name=prefetch,proto3" json:"prefetch,omitempty"`                       // If true, stream entire file (ignore offset/size).
	LocalSize  uint64 `protobuf:"varint,6,opt,name=local_size,json=localSize,proto3" json:"local_size,omitempty"`    // Local file size (for delta detection).
	LocalMtime uint64 `protobuf:"varint,7,opt,name=local_mtime,json=localMtime,proto3" json:"local_mtime,omitempty"` // Local mtime (for delta detection).
	// contains filtered or unexported fields
}

type ReadResponse struct {
	Data      []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	Offset    uint64 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`                        // For delta sync: offset where this chunk applies.
	IsDelta   bool   `protobuf:"varint,3,opt,name=is_delta,json=isDelta,proto3" json:"is_delta,omitempty"`       // True if this is a delta chunk (not full file).
	TotalSize uint64 `protobuf:"varint,4,opt,name=total_size,json=totalSize,proto3" json:"total_size,omitempty"` // Total file size (for prefetch completion).
	// contains filtered or unexported fields
}

type RekeyRequest struct {
	EncSeeds map[string][]byte `` // x25519, mlkem encapsulated seeds
	/* 159-byte string literal not displayed */
	Epoch uint64 `protobuf:"varint,2,opt,name=epoch,proto3" json:"epoch,omitempty"` // monotonic key epoch counter
	// contains filtered or unexported fields
}

type RekeyResponse struct {
	EncSeeds map[string][]byte `` // peer's new encapsulated seeds
	/* 159-byte string literal not displayed */
	Epoch uint64 `protobuf:"varint,2,opt,name=epoch,proto3" json:"epoch,omitempty"` // confirmed epoch
	// contains filtered or unexported fields
}

type StreamFileRequest struct {
	Path        string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	StartOffset uint64 `protobuf:"varint,2,opt,name=start_offset,json=startOffset,proto3" json:"start_offset,omitempty"` // Resume from this byte offset (0 for full file).
	// contains filtered or unexported fields
}

type StreamFileResponse struct {
	Data      []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	Offset    uint64 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`                        // Byte offset where this chunk belongs.
	TotalSize uint64 `protobuf:"varint,3,opt,name=total_size,json=totalSize,proto3" json:"total_size,omitempty"` // Total file size (sent with every chunk for progress).
	// contains filtered or unexported fields
}

type UnimplementedKeibiServiceServer struct{}

type UnsafeKeibiServiceServer interface {
	// contains filtered or unexported methods
}

type WriteRequest struct {
	Handle uint64 `protobuf:"varint,1,opt,name=handle,proto3" json:"handle,omitempty"`
	Path   string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	Data   []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
	Offset uint64 `protobuf:"varint,4,opt,name=offset,proto3" json:"offset,omitempty"`
	Size   uint64 `protobuf:"varint,5,opt,name=size,proto3" json:"size,omitempty"`
	// contains filtered or unexported fields
}

type WriteResponse struct {
	BytesWritten uint32 `protobuf:"varint,1,opt,name=bytes_written,json=bytesWritten,proto3" json:"bytes_written,omitempty"`
	// contains filtered or unexported fields
}