@atproto/ozone 0.0.2

package/src/lexicon/types/app/bsky/embed/images.ts

@@ -0,0 +1,96 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+
+export interface Main {
+  images: Image[]
+  [k: string]: unknown
+}
+
+export function isMain(v: unknown): v is Main {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    (v.$type === 'app.bsky.embed.images#main' ||
+      v.$type === 'app.bsky.embed.images')
+  )
+}
+
+export function validateMain(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.embed.images#main', v)
+}
+
+export interface Image {
+  image: BlobRef
+  alt: string
+  aspectRatio?: AspectRatio
+  [k: string]: unknown
+}
+
+export function isImage(v: unknown): v is Image {
+  return (
+    isObj(v) && hasProp(v, '$type') && v.$type === 'app.bsky.embed.images#image'
+  )
+}
+
+export function validateImage(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.embed.images#image', v)
+}
+
+/** width:height represents an aspect ratio. It may be approximate, and may not correspond to absolute dimensions in any given unit. */
+export interface AspectRatio {
+  width: number
+  height: number
+  [k: string]: unknown
+}
+
+export function isAspectRatio(v: unknown): v is AspectRatio {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.embed.images#aspectRatio'
+  )
+}
+
+export function validateAspectRatio(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.embed.images#aspectRatio', v)
+}
+
+export interface View {
+  images: ViewImage[]
+  [k: string]: unknown
+}
+
+export function isView(v: unknown): v is View {
+  return (
+    isObj(v) && hasProp(v, '$type') && v.$type === 'app.bsky.embed.images#view'
+  )
+}
+
+export function validateView(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.embed.images#view', v)
+}
+
+export interface ViewImage {
+  thumb: string
+  fullsize: string
+  alt: string
+  aspectRatio?: AspectRatio
+  [k: string]: unknown
+}
+
+export function isViewImage(v: unknown): v is ViewImage {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.embed.images#viewImage'
+  )
+}
+
+export function validateViewImage(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.embed.images#viewImage', v)
+}

package/src/lexicon/types/app/bsky/embed/record.ts

@@ -0,0 +1,120 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef'
+import * as AppBskyFeedDefs from '../feed/defs'
+import * as AppBskyGraphDefs from '../graph/defs'
+import * as AppBskyActorDefs from '../actor/defs'
+import * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs'
+import * as AppBskyEmbedImages from './images'
+import * as AppBskyEmbedExternal from './external'
+import * as AppBskyEmbedRecordWithMedia from './recordWithMedia'
+
+export interface Main {
+  record: ComAtprotoRepoStrongRef.Main
+  [k: string]: unknown
+}
+
+export function isMain(v: unknown): v is Main {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    (v.$type === 'app.bsky.embed.record#main' ||
+      v.$type === 'app.bsky.embed.record')
+  )
+}
+
+export function validateMain(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.embed.record#main', v)
+}
+
+export interface View {
+  record:
+    | ViewRecord
+    | ViewNotFound
+    | ViewBlocked
+    | AppBskyFeedDefs.GeneratorView
+    | AppBskyGraphDefs.ListView
+    | { $type: string; [k: string]: unknown }
+  [k: string]: unknown
+}
+
+export function isView(v: unknown): v is View {
+  return (
+    isObj(v) && hasProp(v, '$type') && v.$type === 'app.bsky.embed.record#view'
+  )
+}
+
+export function validateView(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.embed.record#view', v)
+}
+
+export interface ViewRecord {
+  uri: string
+  cid: string
+  author: AppBskyActorDefs.ProfileViewBasic
+  value: {}
+  labels?: ComAtprotoLabelDefs.Label[]
+  embeds?: (
+    | AppBskyEmbedImages.View
+    | AppBskyEmbedExternal.View
+    | View
+    | AppBskyEmbedRecordWithMedia.View
+    | { $type: string; [k: string]: unknown }
+  )[]
+  indexedAt: string
+  [k: string]: unknown
+}
+
+export function isViewRecord(v: unknown): v is ViewRecord {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.embed.record#viewRecord'
+  )
+}
+
+export function validateViewRecord(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.embed.record#viewRecord', v)
+}
+
+export interface ViewNotFound {
+  uri: string
+  notFound: true
+  [k: string]: unknown
+}
+
+export function isViewNotFound(v: unknown): v is ViewNotFound {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.embed.record#viewNotFound'
+  )
+}
+
+export function validateViewNotFound(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.embed.record#viewNotFound', v)
+}
+
+export interface ViewBlocked {
+  uri: string
+  blocked: true
+  author: AppBskyFeedDefs.BlockedAuthor
+  [k: string]: unknown
+}
+
+export function isViewBlocked(v: unknown): v is ViewBlocked {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.embed.record#viewBlocked'
+  )
+}
+
+export function validateViewBlocked(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.embed.record#viewBlocked', v)
+}

package/src/lexicon/types/app/bsky/embed/recordWithMedia.ts

@@ -0,0 +1,53 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import * as AppBskyEmbedRecord from './record'
+import * as AppBskyEmbedImages from './images'
+import * as AppBskyEmbedExternal from './external'
+
+export interface Main {
+  record: AppBskyEmbedRecord.Main
+  media:
+    | AppBskyEmbedImages.Main
+    | AppBskyEmbedExternal.Main
+    | { $type: string; [k: string]: unknown }
+  [k: string]: unknown
+}
+
+export function isMain(v: unknown): v is Main {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    (v.$type === 'app.bsky.embed.recordWithMedia#main' ||
+      v.$type === 'app.bsky.embed.recordWithMedia')
+  )
+}
+
+export function validateMain(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.embed.recordWithMedia#main', v)
+}
+
+export interface View {
+  record: AppBskyEmbedRecord.View
+  media:
+    | AppBskyEmbedImages.View
+    | AppBskyEmbedExternal.View
+    | { $type: string; [k: string]: unknown }
+  [k: string]: unknown
+}
+
+export function isView(v: unknown): v is View {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.embed.recordWithMedia#view'
+  )
+}
+
+export function validateView(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.embed.recordWithMedia#view', v)
+}

package/src/lexicon/types/app/bsky/feed/defs.ts

@@ -0,0 +1,308 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import * as AppBskyActorDefs from '../actor/defs'
+import * as AppBskyEmbedImages from '../embed/images'
+import * as AppBskyEmbedExternal from '../embed/external'
+import * as AppBskyEmbedRecord from '../embed/record'
+import * as AppBskyEmbedRecordWithMedia from '../embed/recordWithMedia'
+import * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs'
+import * as AppBskyRichtextFacet from '../richtext/facet'
+import * as AppBskyGraphDefs from '../graph/defs'
+
+export interface PostView {
+  uri: string
+  cid: string
+  author: AppBskyActorDefs.ProfileViewBasic
+  record: {}
+  embed?:
+    | AppBskyEmbedImages.View
+    | AppBskyEmbedExternal.View
+    | AppBskyEmbedRecord.View
+    | AppBskyEmbedRecordWithMedia.View
+    | { $type: string; [k: string]: unknown }
+  replyCount?: number
+  repostCount?: number
+  likeCount?: number
+  indexedAt: string
+  viewer?: ViewerState
+  labels?: ComAtprotoLabelDefs.Label[]
+  threadgate?: ThreadgateView
+  [k: string]: unknown
+}
+
+export function isPostView(v: unknown): v is PostView {
+  return (
+    isObj(v) && hasProp(v, '$type') && v.$type === 'app.bsky.feed.defs#postView'
+  )
+}
+
+export function validatePostView(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.feed.defs#postView', v)
+}
+
+export interface ViewerState {
+  repost?: string
+  like?: string
+  replyDisabled?: boolean
+  [k: string]: unknown
+}
+
+export function isViewerState(v: unknown): v is ViewerState {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.feed.defs#viewerState'
+  )
+}
+
+export function validateViewerState(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.feed.defs#viewerState', v)
+}
+
+export interface FeedViewPost {
+  post: PostView
+  reply?: ReplyRef
+  reason?: ReasonRepost | { $type: string; [k: string]: unknown }
+  [k: string]: unknown
+}
+
+export function isFeedViewPost(v: unknown): v is FeedViewPost {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.feed.defs#feedViewPost'
+  )
+}
+
+export function validateFeedViewPost(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.feed.defs#feedViewPost', v)
+}
+
+export interface ReplyRef {
+  root:
+    | PostView
+    | NotFoundPost
+    | BlockedPost
+    | { $type: string; [k: string]: unknown }
+  parent:
+    | PostView
+    | NotFoundPost
+    | BlockedPost
+    | { $type: string; [k: string]: unknown }
+  [k: string]: unknown
+}
+
+export function isReplyRef(v: unknown): v is ReplyRef {
+  return (
+    isObj(v) && hasProp(v, '$type') && v.$type === 'app.bsky.feed.defs#replyRef'
+  )
+}
+
+export function validateReplyRef(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.feed.defs#replyRef', v)
+}
+
+export interface ReasonRepost {
+  by: AppBskyActorDefs.ProfileViewBasic
+  indexedAt: string
+  [k: string]: unknown
+}
+
+export function isReasonRepost(v: unknown): v is ReasonRepost {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.feed.defs#reasonRepost'
+  )
+}
+
+export function validateReasonRepost(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.feed.defs#reasonRepost', v)
+}
+
+export interface ThreadViewPost {
+  post: PostView
+  parent?:
+    | ThreadViewPost
+    | NotFoundPost
+    | BlockedPost
+    | { $type: string; [k: string]: unknown }
+  replies?: (
+    | ThreadViewPost
+    | NotFoundPost
+    | BlockedPost
+    | { $type: string; [k: string]: unknown }
+  )[]
+  [k: string]: unknown
+}
+
+export function isThreadViewPost(v: unknown): v is ThreadViewPost {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.feed.defs#threadViewPost'
+  )
+}
+
+export function validateThreadViewPost(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.feed.defs#threadViewPost', v)
+}
+
+export interface NotFoundPost {
+  uri: string
+  notFound: true
+  [k: string]: unknown
+}
+
+export function isNotFoundPost(v: unknown): v is NotFoundPost {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.feed.defs#notFoundPost'
+  )
+}
+
+export function validateNotFoundPost(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.feed.defs#notFoundPost', v)
+}
+
+export interface BlockedPost {
+  uri: string
+  blocked: true
+  author: BlockedAuthor
+  [k: string]: unknown
+}
+
+export function isBlockedPost(v: unknown): v is BlockedPost {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.feed.defs#blockedPost'
+  )
+}
+
+export function validateBlockedPost(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.feed.defs#blockedPost', v)
+}
+
+export interface BlockedAuthor {
+  did: string
+  viewer?: AppBskyActorDefs.ViewerState
+  [k: string]: unknown
+}
+
+export function isBlockedAuthor(v: unknown): v is BlockedAuthor {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.feed.defs#blockedAuthor'
+  )
+}
+
+export function validateBlockedAuthor(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.feed.defs#blockedAuthor', v)
+}
+
+export interface GeneratorView {
+  uri: string
+  cid: string
+  did: string
+  creator: AppBskyActorDefs.ProfileView
+  displayName: string
+  description?: string
+  descriptionFacets?: AppBskyRichtextFacet.Main[]
+  avatar?: string
+  likeCount?: number
+  viewer?: GeneratorViewerState
+  indexedAt: string
+  [k: string]: unknown
+}
+
+export function isGeneratorView(v: unknown): v is GeneratorView {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.feed.defs#generatorView'
+  )
+}
+
+export function validateGeneratorView(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.feed.defs#generatorView', v)
+}
+
+export interface GeneratorViewerState {
+  like?: string
+  [k: string]: unknown
+}
+
+export function isGeneratorViewerState(v: unknown): v is GeneratorViewerState {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.feed.defs#generatorViewerState'
+  )
+}
+
+export function validateGeneratorViewerState(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.feed.defs#generatorViewerState', v)
+}
+
+export interface SkeletonFeedPost {
+  post: string
+  reason?: SkeletonReasonRepost | { $type: string; [k: string]: unknown }
+  [k: string]: unknown
+}
+
+export function isSkeletonFeedPost(v: unknown): v is SkeletonFeedPost {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.feed.defs#skeletonFeedPost'
+  )
+}
+
+export function validateSkeletonFeedPost(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.feed.defs#skeletonFeedPost', v)
+}
+
+export interface SkeletonReasonRepost {
+  repost: string
+  [k: string]: unknown
+}
+
+export function isSkeletonReasonRepost(v: unknown): v is SkeletonReasonRepost {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.feed.defs#skeletonReasonRepost'
+  )
+}
+
+export function validateSkeletonReasonRepost(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.feed.defs#skeletonReasonRepost', v)
+}
+
+export interface ThreadgateView {
+  uri?: string
+  cid?: string
+  record?: {}
+  lists?: AppBskyGraphDefs.ListViewBasic[]
+  [k: string]: unknown
+}
+
+export function isThreadgateView(v: unknown): v is ThreadgateView {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.feed.defs#threadgateView'
+  )
+}
+
+export function validateThreadgateView(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.feed.defs#threadgateView', v)
+}

package/src/lexicon/types/app/bsky/feed/describeFeedGenerator.ts

@@ -0,0 +1,80 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import { HandlerAuth } from '@atproto/xrpc-server'
+
+export interface QueryParams {}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  did: string
+  feeds: Feed[]
+  links?: Links
+  [k: string]: unknown
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput
+
+export interface Feed {
+  uri: string
+  [k: string]: unknown
+}
+
+export function isFeed(v: unknown): v is Feed {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.feed.describeFeedGenerator#feed'
+  )
+}
+
+export function validateFeed(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.feed.describeFeedGenerator#feed', v)
+}
+
+export interface Links {
+  privacyPolicy?: string
+  termsOfService?: string
+  [k: string]: unknown
+}
+
+export function isLinks(v: unknown): v is Links {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.feed.describeFeedGenerator#links'
+  )
+}
+
+export function validateLinks(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.feed.describeFeedGenerator#links', v)
+}

package/src/lexicon/types/app/bsky/feed/generator.ts

@@ -0,0 +1,35 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import * as AppBskyRichtextFacet from '../richtext/facet'
+import * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs'
+
+export interface Record {
+  did: string
+  displayName: string
+  description?: string
+  descriptionFacets?: AppBskyRichtextFacet.Main[]
+  avatar?: BlobRef
+  labels?:
+    | ComAtprotoLabelDefs.SelfLabels
+    | { $type: string; [k: string]: unknown }
+  createdAt: string
+  [k: string]: unknown
+}
+
+export function isRecord(v: unknown): v is Record {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    (v.$type === 'app.bsky.feed.generator#main' ||
+      v.$type === 'app.bsky.feed.generator')
+  )
+}
+
+export function validateRecord(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.feed.generator#main', v)
+}