@atproto/ozone 0.0.2

package/dist/lexicon/types/app/bsky/moderation/getServices.d.ts

@@ -0,0 +1,32 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+import * as AppBskyModerationDefs from './defs';
+export interface QueryParams {
+    dids: string[];
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    views: AppBskyModerationDefs.ModServiceView[];
+    [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;

package/dist/lexicon/types/app/bsky/moderation/service.d.ts

@@ -0,0 +1,17 @@
+import { ValidationResult } from '@atproto/lexicon';
+import * as AppBskyRichtextFacet from '../richtext/facet';
+import * as AppBskyModerationDefs from './defs';
+import * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs';
+export interface Record {
+    description?: string;
+    descriptionFacets?: AppBskyRichtextFacet.Main[];
+    policies: AppBskyModerationDefs.ModServicePolicies;
+    labels?: ComAtprotoLabelDefs.SelfLabels | {
+        $type: string;
+        [k: string]: unknown;
+    };
+    createdAt: string;
+    [k: string]: unknown;
+}
+export declare function isRecord(v: unknown): v is Record;
+export declare function validateRecord(v: unknown): ValidationResult;

package/dist/lexicon/types/app/bsky/notification/getUnreadCount.d.ts

@@ -0,0 +1,31 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+export interface QueryParams {
+    seenAt?: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    count: number;
+    [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;

package/dist/lexicon/types/app/bsky/notification/listNotifications.d.ts

@@ -0,0 +1,52 @@
+import express from 'express';
+import { ValidationResult } from '@atproto/lexicon';
+import { HandlerAuth } from '@atproto/xrpc-server';
+import * as AppBskyActorDefs from '../actor/defs';
+import * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs';
+export interface QueryParams {
+    limit: number;
+    cursor?: string;
+    seenAt?: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    cursor?: string;
+    notifications: Notification[];
+    seenAt?: string;
+    [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 Notification {
+    uri: string;
+    cid: string;
+    author: AppBskyActorDefs.ProfileView;
+    reason: 'like' | 'repost' | 'follow' | 'mention' | 'reply' | 'quote' | (string & {});
+    reasonSubject?: string;
+    record: {};
+    isRead: boolean;
+    indexedAt: string;
+    labels?: ComAtprotoLabelDefs.Label[];
+    [k: string]: unknown;
+}
+export declare function isNotification(v: unknown): v is Notification;
+export declare function validateNotification(v: unknown): ValidationResult;

package/dist/lexicon/types/app/bsky/notification/registerPush.d.ts

@@ -0,0 +1,28 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+export interface QueryParams {
+}
+export interface InputSchema {
+    serviceDid: string;
+    token: string;
+    platform: 'ios' | 'android' | 'web' | (string & {});
+    appId: string;
+    [k: string]: unknown;
+}
+export interface HandlerInput {
+    encoding: 'application/json';
+    body: InputSchema;
+}
+export interface HandlerError {
+    status: number;
+    message?: string;
+}
+export type HandlerOutput = HandlerError | void;
+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;

package/dist/lexicon/types/app/bsky/notification/updateSeen.d.ts

@@ -0,0 +1,25 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+export interface QueryParams {
+}
+export interface InputSchema {
+    seenAt: string;
+    [k: string]: unknown;
+}
+export interface HandlerInput {
+    encoding: 'application/json';
+    body: InputSchema;
+}
+export interface HandlerError {
+    status: number;
+    message?: string;
+}
+export type HandlerOutput = HandlerError | void;
+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;

package/dist/lexicon/types/app/bsky/richtext/facet.d.ts

@@ -0,0 +1,36 @@
+import { ValidationResult } from '@atproto/lexicon';
+export interface Main {
+    index: ByteSlice;
+    features: (Mention | Link | Tag | {
+        $type: string;
+        [k: string]: unknown;
+    })[];
+    [k: string]: unknown;
+}
+export declare function isMain(v: unknown): v is Main;
+export declare function validateMain(v: unknown): ValidationResult;
+export interface Mention {
+    did: string;
+    [k: string]: unknown;
+}
+export declare function isMention(v: unknown): v is Mention;
+export declare function validateMention(v: unknown): ValidationResult;
+export interface Link {
+    uri: string;
+    [k: string]: unknown;
+}
+export declare function isLink(v: unknown): v is Link;
+export declare function validateLink(v: unknown): ValidationResult;
+export interface Tag {
+    tag: string;
+    [k: string]: unknown;
+}
+export declare function isTag(v: unknown): v is Tag;
+export declare function validateTag(v: unknown): ValidationResult;
+export interface ByteSlice {
+    byteStart: number;
+    byteEnd: number;
+    [k: string]: unknown;
+}
+export declare function isByteSlice(v: unknown): v is ByteSlice;
+export declare function validateByteSlice(v: unknown): ValidationResult;

package/dist/lexicon/types/app/bsky/unspecced/defs.d.ts

@@ -0,0 +1,13 @@
+import { ValidationResult } from '@atproto/lexicon';
+export interface SkeletonSearchPost {
+    uri: string;
+    [k: string]: unknown;
+}
+export declare function isSkeletonSearchPost(v: unknown): v is SkeletonSearchPost;
+export declare function validateSkeletonSearchPost(v: unknown): ValidationResult;
+export interface SkeletonSearchActor {
+    did: string;
+    [k: string]: unknown;
+}
+export declare function isSkeletonSearchActor(v: unknown): v is SkeletonSearchActor;
+export declare function validateSkeletonSearchActor(v: unknown): ValidationResult;

package/dist/lexicon/types/app/bsky/unspecced/getPopular.d.ts

@@ -0,0 +1,35 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+import * as AppBskyFeedDefs from '../feed/defs';
+export interface QueryParams {
+    includeNsfw: boolean;
+    limit: number;
+    cursor?: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    cursor?: string;
+    feed: AppBskyFeedDefs.FeedViewPost[];
+    [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;

package/dist/lexicon/types/app/bsky/unspecced/getPopularFeedGenerators.d.ts

@@ -0,0 +1,35 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+import * as AppBskyFeedDefs from '../feed/defs';
+export interface QueryParams {
+    limit: number;
+    cursor?: string;
+    query?: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    cursor?: string;
+    feeds: AppBskyFeedDefs.GeneratorView[];
+    [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;

package/dist/lexicon/types/app/bsky/unspecced/getTimelineSkeleton.d.ts

@@ -0,0 +1,35 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+import * as AppBskyFeedDefs from '../feed/defs';
+export interface QueryParams {
+    limit: number;
+    cursor?: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    cursor?: string;
+    feed: AppBskyFeedDefs.SkeletonFeedPost[];
+    [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;
+    error?: 'UnknownFeed';
+}
+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;

package/dist/lexicon/types/app/bsky/unspecced/searchActorsSkeleton.d.ts

@@ -0,0 +1,38 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+import * as AppBskyUnspeccedDefs from './defs';
+export interface QueryParams {
+    q: string;
+    typeahead?: boolean;
+    limit: number;
+    cursor?: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    cursor?: string;
+    hitsTotal?: number;
+    actors: AppBskyUnspeccedDefs.SkeletonSearchActor[];
+    [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;
+    error?: 'BadQueryString';
+}
+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;

package/dist/lexicon/types/app/bsky/unspecced/searchPostsSkeleton.d.ts

@@ -0,0 +1,37 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+import * as AppBskyUnspeccedDefs from './defs';
+export interface QueryParams {
+    q: string;
+    limit: number;
+    cursor?: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    cursor?: string;
+    hitsTotal?: number;
+    posts: AppBskyUnspeccedDefs.SkeletonSearchPost[];
+    [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;
+    error?: 'BadQueryString';
+}
+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;