@mepuka/skygent 0.2.0

package/src/domain/bsky.ts

@@ -0,0 +1,467 @@
+import { Schema } from "effect";
+import { AtUri, Did, Handle, PostCid, PostUri, Timestamp } from "./primitives.js";
+
+export const AuthorFeedFilter = Schema.Literal(
+  "posts_with_replies",
+  "posts_no_replies",
+  "posts_with_media",
+  "posts_and_author_threads"
+);
+export type AuthorFeedFilter = typeof AuthorFeedFilter.Type;
+
+export class StrongRef extends Schema.Class<StrongRef>("StrongRef")({
+  uri: AtUri,
+  cid: PostCid
+}) {}
+
+export class ReplyRef extends Schema.Class<ReplyRef>("ReplyRef")({
+  root: StrongRef,
+  parent: StrongRef
+}) {}
+
+export const FacetIndex = Schema.Struct({
+  byteStart: Schema.Int,
+  byteEnd: Schema.Int
+});
+export type FacetIndex = typeof FacetIndex.Type;
+
+export const FacetMentionFeature = Schema.Struct({
+  $type: Schema.Literal("app.bsky.richtext.facet#mention"),
+  did: Did
+});
+export type FacetMentionFeature = typeof FacetMentionFeature.Type;
+
+export const FacetLinkFeature = Schema.Struct({
+  $type: Schema.Literal("app.bsky.richtext.facet#link"),
+  uri: Schema.String
+});
+export type FacetLinkFeature = typeof FacetLinkFeature.Type;
+
+export const FacetTagFeature = Schema.Struct({
+  $type: Schema.Literal("app.bsky.richtext.facet#tag"),
+  tag: Schema.String
+});
+export type FacetTagFeature = typeof FacetTagFeature.Type;
+
+export const FacetUnknownFeature = Schema.Struct({
+  $type: Schema.String
+});
+export type FacetUnknownFeature = typeof FacetUnknownFeature.Type;
+
+export const FacetFeature = Schema.Union(
+  FacetMentionFeature,
+  FacetLinkFeature,
+  FacetTagFeature,
+  FacetUnknownFeature
+);
+export type FacetFeature = typeof FacetFeature.Type;
+
+export const RichTextFacet = Schema.Struct({
+  index: FacetIndex,
+  features: Schema.Array(FacetFeature)
+});
+export type RichTextFacet = typeof RichTextFacet.Type;
+
+export const LegacyFacetIndex = Schema.Struct({
+  start: Schema.Int,
+  end: Schema.Int
+});
+export type LegacyFacetIndex = typeof LegacyFacetIndex.Type;
+
+export const LegacyEntity = Schema.Struct({
+  index: LegacyFacetIndex,
+  type: Schema.String,
+  value: Schema.String
+});
+export type LegacyEntity = typeof LegacyEntity.Type;
+
+export const SelfLabel = Schema.Struct({
+  $type: Schema.optional(Schema.Literal("com.atproto.label.defs#selfLabel")),
+  val: Schema.String
+});
+export type SelfLabel = typeof SelfLabel.Type;
+
+export const SelfLabels = Schema.Struct({
+  $type: Schema.optional(Schema.Literal("com.atproto.label.defs#selfLabels")),
+  values: Schema.Array(SelfLabel)
+});
+export type SelfLabels = typeof SelfLabels.Type;
+
+export class Label extends Schema.Class<Label>("Label")({
+  $type: Schema.optional(Schema.Literal("com.atproto.label.defs#label")),
+  ver: Schema.optional(Schema.Int),
+  src: Did,
+  uri: AtUri,
+  cid: Schema.optional(Schema.String),
+  val: Schema.String,
+  neg: Schema.optional(Schema.Boolean),
+  cts: Timestamp,
+  exp: Schema.optional(Timestamp),
+  sig: Schema.optional(
+    Schema.Union(Schema.Uint8ArrayFromSelf, Schema.Uint8ArrayFromBase64)
+  )
+}) {}
+
+const NonNegativeInt = Schema.Int.pipe(
+  Schema.finite(),
+  Schema.nonNegative()
+);
+
+export class PostMetrics extends Schema.Class<PostMetrics>("PostMetrics")({
+  replyCount: Schema.optional(NonNegativeInt),
+  repostCount: Schema.optional(NonNegativeInt),
+  likeCount: Schema.optional(NonNegativeInt),
+  quoteCount: Schema.optional(NonNegativeInt),
+  bookmarkCount: Schema.optional(NonNegativeInt)
+}) {}
+
+export class EmbedAspectRatio extends Schema.Class<EmbedAspectRatio>("EmbedAspectRatio")({
+  width: Schema.Int,
+  height: Schema.Int
+}) {}
+
+export class EmbedImage extends Schema.Class<EmbedImage>("EmbedImage")({
+  thumb: Schema.String,
+  fullsize: Schema.String,
+  alt: Schema.String,
+  aspectRatio: Schema.optional(EmbedAspectRatio)
+}) {}
+
+export class EmbedImages extends Schema.TaggedClass<EmbedImages>()("Images", {
+  images: Schema.Array(EmbedImage)
+}) {}
+
+export class EmbedExternal extends Schema.TaggedClass<EmbedExternal>()("External", {
+  uri: Schema.String,
+  title: Schema.String,
+  description: Schema.String,
+  thumb: Schema.optional(Schema.String)
+}) {}
+
+export class EmbedVideo extends Schema.TaggedClass<EmbedVideo>()("Video", {
+  cid: Schema.String,
+  playlist: Schema.String,
+  thumbnail: Schema.optional(Schema.String),
+  alt: Schema.optional(Schema.String),
+  aspectRatio: Schema.optional(EmbedAspectRatio)
+}) {}
+
+export class ProfileBasic extends Schema.Class<ProfileBasic>("ProfileBasic")({
+  did: Did,
+  handle: Handle,
+  displayName: Schema.optional(Schema.String),
+  pronouns: Schema.optional(Schema.String),
+  avatar: Schema.optional(Schema.String),
+  associated: Schema.optional(Schema.Unknown),
+  viewer: Schema.optional(Schema.Unknown),
+  labels: Schema.optional(Schema.Array(Schema.encodedSchema(Label))),
+  createdAt: Schema.optional(Schema.String),
+  verification: Schema.optional(Schema.Unknown),
+  status: Schema.optional(Schema.Unknown),
+  debug: Schema.optional(Schema.Unknown)
+}) {}
+
+export class ProfileView extends Schema.Class<ProfileView>("ProfileView")({
+  did: Did,
+  handle: Handle,
+  displayName: Schema.optional(Schema.String),
+  pronouns: Schema.optional(Schema.String),
+  description: Schema.optional(Schema.String),
+  avatar: Schema.optional(Schema.String),
+  associated: Schema.optional(Schema.Unknown),
+  indexedAt: Schema.optional(Schema.String),
+  createdAt: Schema.optional(Schema.String),
+  viewer: Schema.optional(Schema.Unknown),
+  labels: Schema.optional(Schema.Array(Schema.encodedSchema(Label))),
+  verification: Schema.optional(Schema.Unknown),
+  status: Schema.optional(Schema.Unknown),
+  debug: Schema.optional(Schema.Unknown)
+}) {}
+
+export class IdentityInfo extends Schema.Class<IdentityInfo>("IdentityInfo")({
+  did: Did,
+  handle: Handle,
+  didDoc: Schema.Unknown
+}) {}
+
+export class EmbedRecordView extends Schema.TaggedClass<EmbedRecordView>()(
+  "RecordView",
+  {
+    uri: PostUri,
+    cid: PostCid,
+    author: ProfileBasic,
+    value: Schema.Unknown,
+    labels: Schema.optional(Schema.Array(Label)),
+    metrics: Schema.optional(PostMetrics),
+    embeds: Schema.optional(Schema.Array(Schema.Unknown)),
+    indexedAt: Timestamp
+  }
+) {}
+
+export class EmbedRecordNotFound extends Schema.TaggedClass<EmbedRecordNotFound>()(
+  "RecordNotFound",
+  {
+    uri: PostUri,
+    notFound: Schema.Literal(true)
+  }
+) {}
+
+export class BlockedAuthor extends Schema.Class<BlockedAuthor>("BlockedAuthor")({
+  did: Did,
+  viewer: Schema.optional(Schema.Unknown)
+}) {}
+
+export class EmbedRecordBlocked extends Schema.TaggedClass<EmbedRecordBlocked>()(
+  "RecordBlocked",
+  {
+    uri: PostUri,
+    blocked: Schema.Literal(true),
+    author: BlockedAuthor
+  }
+) {}
+
+export class EmbedRecordDetached extends Schema.TaggedClass<EmbedRecordDetached>()(
+  "RecordDetached",
+  {
+    uri: PostUri,
+    detached: Schema.Literal(true)
+  }
+) {}
+
+export class EmbedRecordUnknown extends Schema.TaggedClass<EmbedRecordUnknown>()(
+  "RecordUnknown",
+  {
+    rawType: Schema.String,
+    data: Schema.Unknown
+  }
+) {}
+
+export const EmbedRecordTarget = Schema.Union(
+  EmbedRecordView,
+  EmbedRecordNotFound,
+  EmbedRecordBlocked,
+  EmbedRecordDetached,
+  EmbedRecordUnknown
+);
+export type EmbedRecordTarget = typeof EmbedRecordTarget.Type;
+
+export class EmbedRecord extends Schema.TaggedClass<EmbedRecord>()("Record", {
+  recordType: Schema.optional(Schema.String),
+  record: Schema.suspend(() => EmbedRecordTarget)
+}) {}
+
+export class EmbedRecordWithMedia extends Schema.TaggedClass<EmbedRecordWithMedia>()(
+  "RecordWithMedia",
+  {
+    recordType: Schema.optional(Schema.String),
+    record: Schema.suspend(() => EmbedRecordTarget),
+    media: Schema.Union(EmbedImages, EmbedExternal, EmbedVideo, Schema.Unknown)
+  }
+) {}
+
+export class EmbedUnknown extends Schema.TaggedClass<EmbedUnknown>()("Unknown", {
+  rawType: Schema.String,
+  data: Schema.Unknown
+}) {}
+
+export const PostEmbed = Schema.Union(
+  EmbedImages,
+  EmbedExternal,
+  EmbedVideo,
+  EmbedRecord,
+  EmbedRecordWithMedia,
+  EmbedUnknown
+);
+export type PostEmbed = typeof PostEmbed.Type;
+
+export const PostViewerState = Schema.Struct({
+  repost: Schema.optional(AtUri),
+  like: Schema.optional(AtUri),
+  bookmarked: Schema.optional(Schema.Boolean),
+  threadMuted: Schema.optional(Schema.Boolean),
+  replyDisabled: Schema.optional(Schema.Boolean),
+  embeddingDisabled: Schema.optional(Schema.Boolean),
+  pinned: Schema.optional(Schema.Boolean)
+});
+export type PostViewerState = typeof PostViewerState.Type;
+
+export const ThreadgateView = Schema.Struct({
+  uri: Schema.optional(AtUri),
+  cid: Schema.optional(Schema.String),
+  record: Schema.optional(Schema.Unknown),
+  lists: Schema.optional(Schema.Array(Schema.Unknown))
+});
+export type ThreadgateView = typeof ThreadgateView.Type;
+
+export class FeedPostViewRef extends Schema.Class<FeedPostViewRef>("FeedPostViewRef")({
+  uri: PostUri,
+  cid: PostCid,
+  author: ProfileBasic,
+  indexedAt: Timestamp,
+  labels: Schema.optional(Schema.Array(Label)),
+  viewer: Schema.optional(PostViewerState)
+}) {}
+
+export class FeedPostNotFound extends Schema.TaggedClass<FeedPostNotFound>()(
+  "FeedPostNotFound",
+  {
+    uri: PostUri,
+    notFound: Schema.Literal(true)
+  }
+) {}
+
+export class FeedPostBlocked extends Schema.TaggedClass<FeedPostBlocked>()(
+  "FeedPostBlocked",
+  {
+    uri: PostUri,
+    blocked: Schema.Literal(true),
+    author: BlockedAuthor
+  }
+) {}
+
+export class FeedPostUnknown extends Schema.TaggedClass<FeedPostUnknown>()(
+  "FeedPostUnknown",
+  {
+    rawType: Schema.String,
+    data: Schema.Unknown
+  }
+) {}
+
+export const FeedPostReference = Schema.Union(
+  FeedPostViewRef,
+  FeedPostNotFound,
+  FeedPostBlocked,
+  FeedPostUnknown
+);
+export type FeedPostReference = typeof FeedPostReference.Type;
+
+export class FeedReplyRef extends Schema.Class<FeedReplyRef>("FeedReplyRef")({
+  root: FeedPostReference,
+  parent: FeedPostReference,
+  grandparentAuthor: Schema.optional(ProfileBasic)
+}) {}
+
+export class FeedReasonRepost extends Schema.TaggedClass<FeedReasonRepost>()(
+  "ReasonRepost",
+  {
+    by: ProfileBasic,
+    uri: Schema.optional(PostUri),
+    cid: Schema.optional(PostCid),
+    indexedAt: Timestamp
+  }
+) {}
+
+export class FeedReasonPin extends Schema.TaggedClass<FeedReasonPin>()("ReasonPin", {}) {}
+
+export class FeedReasonUnknown extends Schema.TaggedClass<FeedReasonUnknown>()(
+  "ReasonUnknown",
+  {
+    rawType: Schema.String,
+    data: Schema.Unknown
+  }
+) {}
+
+export const FeedReason = Schema.Union(
+  FeedReasonRepost,
+  FeedReasonPin,
+  FeedReasonUnknown
+);
+export type FeedReason = typeof FeedReason.Type;
+
+export class FeedContext extends Schema.Class<FeedContext>("FeedContext")({
+  reply: Schema.optional(FeedReplyRef),
+  reason: Schema.optional(FeedReason),
+  feedContext: Schema.optional(Schema.String),
+  reqId: Schema.optional(Schema.String)
+}) {}
+
+export class FeedGeneratorViewerState extends Schema.Class<FeedGeneratorViewerState>(
+  "FeedGeneratorViewerState"
+)({
+  like: Schema.optional(AtUri)
+}) {}
+
+export class FeedGeneratorView extends Schema.Class<FeedGeneratorView>("FeedGeneratorView")({
+  uri: AtUri,
+  cid: PostCid,
+  did: Did,
+  creator: ProfileView,
+  displayName: Schema.String,
+  description: Schema.optional(Schema.String),
+  descriptionFacets: Schema.optional(Schema.Array(Schema.Unknown)),
+  avatar: Schema.optional(Schema.String),
+  likeCount: Schema.optional(NonNegativeInt),
+  acceptsInteractions: Schema.optional(Schema.Boolean),
+  labels: Schema.optional(Schema.Array(Label)),
+  viewer: Schema.optional(FeedGeneratorViewerState),
+  contentMode: Schema.optional(Schema.String),
+  indexedAt: Timestamp
+}) {}
+
+export class PostLike extends Schema.Class<PostLike>("PostLike")({
+  actor: ProfileView,
+  createdAt: Timestamp,
+  indexedAt: Timestamp
+}) {}
+
+export const ListPurpose = Schema.Literal(
+  "app.bsky.graph.defs#modlist",
+  "app.bsky.graph.defs#curatelist",
+  "app.bsky.graph.defs#referencelist"
+);
+export type ListPurpose = typeof ListPurpose.Type;
+
+export class ListViewerState extends Schema.Class<ListViewerState>("ListViewerState")({
+  muted: Schema.optional(Schema.Boolean),
+  blocked: Schema.optional(AtUri)
+}) {}
+
+export class ListViewBasic extends Schema.Class<ListViewBasic>("ListViewBasic")({
+  uri: AtUri,
+  cid: PostCid,
+  name: Schema.String,
+  purpose: ListPurpose,
+  avatar: Schema.optional(Schema.String),
+  listItemCount: Schema.optional(NonNegativeInt),
+  labels: Schema.optional(Schema.Array(Label)),
+  viewer: Schema.optional(ListViewerState),
+  indexedAt: Schema.optional(Timestamp)
+}) {}
+
+export class ListView extends Schema.Class<ListView>("ListView")({
+  uri: AtUri,
+  cid: PostCid,
+  creator: ProfileView,
+  name: Schema.String,
+  purpose: ListPurpose,
+  description: Schema.optional(Schema.String),
+  descriptionFacets: Schema.optional(Schema.Array(RichTextFacet)),
+  avatar: Schema.optional(Schema.String),
+  listItemCount: Schema.optional(NonNegativeInt),
+  labels: Schema.optional(Schema.Array(Label)),
+  viewer: Schema.optional(ListViewerState),
+  indexedAt: Timestamp
+}) {}
+
+export class ListItemView extends Schema.Class<ListItemView>("ListItemView")({
+  uri: AtUri,
+  subject: ProfileView
+}) {}
+
+export class Relationship extends Schema.Class<Relationship>("Relationship")({
+  did: Did,
+  following: Schema.optional(AtUri),
+  followedBy: Schema.optional(AtUri),
+  blocking: Schema.optional(AtUri),
+  blockedBy: Schema.optional(AtUri),
+  blockingByList: Schema.optional(AtUri),
+  blockedByList: Schema.optional(AtUri)
+}) {}
+
+export class NotFoundActor extends Schema.Class<NotFoundActor>("NotFoundActor")({
+  actor: Schema.String,
+  notFound: Schema.Literal(true)
+}) {}
+
+export const RelationshipView = Schema.Union(Relationship, NotFoundActor);
+export type RelationshipView = typeof RelationshipView.Type;

package/src/domain/config.ts

@@ -0,0 +1,11 @@
+import { Schema } from "effect";
+
+export const OutputFormat = Schema.Literal("json", "ndjson", "markdown", "table");
+export type OutputFormat = typeof OutputFormat.Type;
+
+export class AppConfig extends Schema.Class<AppConfig>("AppConfig")({
+  service: Schema.String,
+  storeRoot: Schema.String,
+  outputFormat: OutputFormat,
+  identifier: Schema.optional(Schema.String)
+}) {}

package/src/domain/credentials.ts

@@ -0,0 +1,6 @@
+import { Schema } from "effect";
+
+export class BskyCredentials extends Schema.Class<BskyCredentials>("BskyCredentials")({
+  identifier: Schema.String,
+  password: Schema.Redacted(Schema.String)
+}) {}

package/src/domain/defaults.ts

@@ -0,0 +1,8 @@
+import { StoreConfig } from "./store.js";
+
+export const defaultStoreConfig = StoreConfig.make({
+  format: { json: true, markdown: false },
+  autoSync: false,
+  syncPolicy: "dedupe",
+  filters: []
+});

package/src/domain/derivation.ts

@@ -0,0 +1,55 @@
+import { Schema } from "effect";
+import { StoreName, Timestamp, EventSeq } from "./primitives.js";
+import { FilterExprSchema } from "./filter.js";
+
+export const FilterEvaluationMode = Schema.Literal("EventTime", "DeriveTime");
+export type FilterEvaluationMode = typeof FilterEvaluationMode.Type;
+
+export class StoreSource extends Schema.Class<StoreSource>("StoreSource")({
+  storeName: StoreName,
+  filter: FilterExprSchema,
+  filterHash: Schema.String,
+  evaluationMode: FilterEvaluationMode,
+  derivedAt: Timestamp
+}) {}
+
+export class DerivationResult extends Schema.Class<DerivationResult>(
+  "DerivationResult"
+)({
+  eventsProcessed: Schema.NonNegativeInt,
+  eventsMatched: Schema.NonNegativeInt,
+  eventsSkipped: Schema.NonNegativeInt,
+  deletesPropagated: Schema.NonNegativeInt,
+  durationMs: Schema.Number
+}) {}
+
+export class DerivationCheckpoint extends Schema.Class<DerivationCheckpoint>(
+  "DerivationCheckpoint"
+)({
+  viewName: StoreName,
+  sourceStore: StoreName,
+  targetStore: StoreName,
+  filterHash: Schema.String,
+  evaluationMode: FilterEvaluationMode,
+  lastSourceEventSeq: Schema.optional(EventSeq),
+  eventsProcessed: Schema.NonNegativeInt,
+  eventsMatched: Schema.NonNegativeInt,
+  deletesPropagated: Schema.NonNegativeInt,
+  updatedAt: Timestamp
+}) {}
+
+export class StoreLineage extends Schema.Class<StoreLineage>("StoreLineage")({
+  storeName: StoreName,
+  isDerived: Schema.Boolean,
+  sources: Schema.Array(StoreSource),
+  updatedAt: Timestamp
+}) {}
+
+export class DerivationError extends Schema.TaggedError<DerivationError>()(
+  "DerivationError",
+  {
+    reason: Schema.String,
+    sourceStore: Schema.optional(StoreName),
+    targetStore: Schema.optional(StoreName)
+  }
+) {}

package/src/domain/errors.ts

@@ -0,0 +1,71 @@
+import { Schema } from "effect";
+import { StoreName, StorePath } from "./primitives.js";
+
+export class FilterCompileError extends Schema.TaggedError<FilterCompileError>()(
+  "FilterCompileError",
+  { message: Schema.String }
+) {}
+
+export class FilterEvalError extends Schema.TaggedError<FilterEvalError>()(
+  "FilterEvalError",
+  { message: Schema.String, cause: Schema.optional(Schema.Unknown) }
+) {}
+
+export class BskyError extends Schema.TaggedError<BskyError>()(
+  "BskyError",
+  {
+    message: Schema.String,
+    cause: Schema.optional(Schema.Unknown),
+    operation: Schema.optional(Schema.String),
+    status: Schema.optional(Schema.Number),
+    error: Schema.optional(Schema.String),
+    detail: Schema.optional(Schema.String)
+  }
+) {}
+
+export class ConfigError extends Schema.TaggedError<ConfigError>()(
+  "ConfigError",
+  {
+    message: Schema.String,
+    path: Schema.optional(Schema.String),
+    cause: Schema.optional(Schema.Unknown)
+  }
+) {}
+
+export class CredentialError extends Schema.TaggedError<CredentialError>()(
+  "CredentialError",
+  { message: Schema.String, cause: Schema.optional(Schema.Unknown) }
+) {}
+
+export class StoreNotFound extends Schema.TaggedError<StoreNotFound>()(
+  "StoreNotFound",
+  { name: StoreName }
+) {}
+
+export class StoreIoError extends Schema.TaggedError<StoreIoError>()(
+  "StoreIoError",
+  { path: StorePath, cause: Schema.Unknown }
+) {}
+
+export class StoreIndexError extends Schema.TaggedError<StoreIndexError>()(
+  "StoreIndexError",
+  { message: Schema.String, cause: Schema.optional(Schema.Unknown) }
+) {}
+
+
+export class FilterNotFound extends Schema.TaggedError<FilterNotFound>()(
+  "FilterNotFound",
+  { name: Schema.String }
+) {}
+
+export class FilterLibraryError extends Schema.TaggedError<FilterLibraryError>()(
+  "FilterLibraryError",
+  {
+    message: Schema.String,
+    name: Schema.optional(Schema.String),
+    path: Schema.optional(Schema.String),
+    cause: Schema.optional(Schema.Unknown)
+  }
+) {}
+
+export type StoreError = StoreNotFound | StoreIoError | StoreIndexError;

package/src/domain/events.ts

@@ -0,0 +1,55 @@
+import { Schema } from "effect";
+import { Post } from "./post.js";
+import { EventId, EventSeq, PostCid, PostUri, Timestamp, StoreName } from "./primitives.js";
+import { FilterExprSchema } from "./filter.js";
+
+export const StoreQueryOrder = Schema.Literal("asc", "desc");
+export type StoreQueryOrder = typeof StoreQueryOrder.Type;
+
+export class EventMeta extends Schema.Class<EventMeta>("EventMeta")({
+  source: Schema.Literal(
+    "timeline",
+    "notifications",
+    "jetstream",
+    "feed",
+    "list",
+    "author",
+    "thread"
+  ),
+  command: Schema.String,
+  filterExprHash: Schema.optional(Schema.String),
+  createdAt: Timestamp,
+  sourceStore: Schema.optional(StoreName)
+}) {}
+
+export class PostUpsert extends Schema.TaggedClass<PostUpsert>()("PostUpsert", {
+  post: Post,
+  meta: EventMeta
+}) {}
+
+export class PostDelete extends Schema.TaggedClass<PostDelete>()("PostDelete", {
+  uri: PostUri,
+  cid: Schema.optional(PostCid),
+  meta: EventMeta
+}) {}
+
+export const PostEvent = Schema.Union(PostUpsert, PostDelete);
+export type PostEvent = typeof PostEvent.Type;
+
+export class PostEventRecord extends Schema.Class<PostEventRecord>("PostEventRecord")({
+  id: EventId,
+  version: Schema.Literal(1),
+  event: PostEvent
+}) {}
+
+export type EventLogEntry = {
+  readonly seq: EventSeq;
+  readonly record: PostEventRecord;
+};
+
+export class StoreQuery extends Schema.Class<StoreQuery>("StoreQuery")({
+  range: Schema.optional(Schema.Struct({ start: Timestamp, end: Timestamp })),
+  filter: Schema.optional(FilterExprSchema),
+  scanLimit: Schema.optional(Schema.NonNegativeInt),
+  order: Schema.optional(StoreQueryOrder)
+}) {}