@atproto/ozone 0.0.2

package/dist/lexicon/types/app/bsky/feed/searchPosts.d.ts

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

@@ -0,0 +1,28 @@
+import { ValidationResult } from '@atproto/lexicon';
+export interface Record {
+    post: string;
+    allow?: (MentionRule | FollowingRule | ListRule | {
+        $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;
+export interface MentionRule {
+    [k: string]: unknown;
+}
+export declare function isMentionRule(v: unknown): v is MentionRule;
+export declare function validateMentionRule(v: unknown): ValidationResult;
+export interface FollowingRule {
+    [k: string]: unknown;
+}
+export declare function isFollowingRule(v: unknown): v is FollowingRule;
+export declare function validateFollowingRule(v: unknown): ValidationResult;
+export interface ListRule {
+    list: string;
+    [k: string]: unknown;
+}
+export declare function isListRule(v: unknown): v is ListRule;
+export declare function validateListRule(v: unknown): ValidationResult;

package/dist/lexicon/types/app/bsky/graph/block.d.ts

@@ -0,0 +1,8 @@
+import { ValidationResult } from '@atproto/lexicon';
+export interface Record {
+    subject: string;
+    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/graph/defs.d.ts

@@ -0,0 +1,47 @@
+import { ValidationResult } from '@atproto/lexicon';
+import * as AppBskyActorDefs from '../actor/defs';
+import * as AppBskyRichtextFacet from '../richtext/facet';
+export interface ListViewBasic {
+    uri: string;
+    cid: string;
+    name: string;
+    purpose: ListPurpose;
+    avatar?: string;
+    viewer?: ListViewerState;
+    indexedAt?: string;
+    [k: string]: unknown;
+}
+export declare function isListViewBasic(v: unknown): v is ListViewBasic;
+export declare function validateListViewBasic(v: unknown): ValidationResult;
+export interface ListView {
+    uri: string;
+    cid: string;
+    creator: AppBskyActorDefs.ProfileView;
+    name: string;
+    purpose: ListPurpose;
+    description?: string;
+    descriptionFacets?: AppBskyRichtextFacet.Main[];
+    avatar?: string;
+    viewer?: ListViewerState;
+    indexedAt: string;
+    [k: string]: unknown;
+}
+export declare function isListView(v: unknown): v is ListView;
+export declare function validateListView(v: unknown): ValidationResult;
+export interface ListItemView {
+    uri: string;
+    subject: AppBskyActorDefs.ProfileView;
+    [k: string]: unknown;
+}
+export declare function isListItemView(v: unknown): v is ListItemView;
+export declare function validateListItemView(v: unknown): ValidationResult;
+export type ListPurpose = 'app.bsky.graph.defs#modlist' | 'app.bsky.graph.defs#curatelist' | (string & {});
+export declare const MODLIST = "app.bsky.graph.defs#modlist";
+export declare const CURATELIST = "app.bsky.graph.defs#curatelist";
+export interface ListViewerState {
+    muted?: boolean;
+    blocked?: string;
+    [k: string]: unknown;
+}
+export declare function isListViewerState(v: unknown): v is ListViewerState;
+export declare function validateListViewerState(v: unknown): ValidationResult;

package/dist/lexicon/types/app/bsky/graph/follow.d.ts

@@ -0,0 +1,8 @@
+import { ValidationResult } from '@atproto/lexicon';
+export interface Record {
+    subject: string;
+    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/graph/getBlocks.d.ts

@@ -0,0 +1,34 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+import * as AppBskyActorDefs from '../actor/defs';
+export interface QueryParams {
+    limit: number;
+    cursor?: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    cursor?: string;
+    blocks: AppBskyActorDefs.ProfileView[];
+    [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/graph/getFollowers.d.ts

@@ -0,0 +1,36 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+import * as AppBskyActorDefs from '../actor/defs';
+export interface QueryParams {
+    actor: string;
+    limit: number;
+    cursor?: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    subject: AppBskyActorDefs.ProfileView;
+    cursor?: string;
+    followers: AppBskyActorDefs.ProfileView[];
+    [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/graph/getFollows.d.ts

@@ -0,0 +1,36 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+import * as AppBskyActorDefs from '../actor/defs';
+export interface QueryParams {
+    actor: string;
+    limit: number;
+    cursor?: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    subject: AppBskyActorDefs.ProfileView;
+    cursor?: string;
+    follows: AppBskyActorDefs.ProfileView[];
+    [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/graph/getList.d.ts

@@ -0,0 +1,36 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+import * as AppBskyGraphDefs from './defs';
+export interface QueryParams {
+    list: string;
+    limit: number;
+    cursor?: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    cursor?: string;
+    list: AppBskyGraphDefs.ListView;
+    items: AppBskyGraphDefs.ListItemView[];
+    [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/graph/getListBlocks.d.ts

@@ -0,0 +1,34 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+import * as AppBskyGraphDefs from './defs';
+export interface QueryParams {
+    limit: number;
+    cursor?: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    cursor?: string;
+    lists: AppBskyGraphDefs.ListView[];
+    [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/graph/getListMutes.d.ts

@@ -0,0 +1,34 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+import * as AppBskyGraphDefs from './defs';
+export interface QueryParams {
+    limit: number;
+    cursor?: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    cursor?: string;
+    lists: AppBskyGraphDefs.ListView[];
+    [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/graph/getLists.d.ts

@@ -0,0 +1,35 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+import * as AppBskyGraphDefs from './defs';
+export interface QueryParams {
+    actor: string;
+    limit: number;
+    cursor?: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    cursor?: string;
+    lists: AppBskyGraphDefs.ListView[];
+    [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/graph/getMutes.d.ts

@@ -0,0 +1,34 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+import * as AppBskyActorDefs from '../actor/defs';
+export interface QueryParams {
+    limit: number;
+    cursor?: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    cursor?: string;
+    mutes: AppBskyActorDefs.ProfileView[];
+    [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/graph/getSuggestedFollowsByActor.d.ts

@@ -0,0 +1,32 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+import * as AppBskyActorDefs from '../actor/defs';
+export interface QueryParams {
+    actor: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    suggestions: AppBskyActorDefs.ProfileView[];
+    [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/graph/list.d.ts

@@ -0,0 +1,19 @@
+import { ValidationResult, BlobRef } from '@atproto/lexicon';
+import * as AppBskyGraphDefs from './defs';
+import * as AppBskyRichtextFacet from '../richtext/facet';
+import * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs';
+export interface Record {
+    purpose: AppBskyGraphDefs.ListPurpose;
+    name: string;
+    description?: string;
+    descriptionFacets?: AppBskyRichtextFacet.Main[];
+    avatar?: BlobRef;
+    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/graph/listblock.d.ts

@@ -0,0 +1,8 @@
+import { ValidationResult } from '@atproto/lexicon';
+export interface Record {
+    subject: string;
+    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/graph/listitem.d.ts

@@ -0,0 +1,9 @@
+import { ValidationResult } from '@atproto/lexicon';
+export interface Record {
+    subject: string;
+    list: string;
+    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/graph/muteActor.d.ts

@@ -0,0 +1,25 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+export interface QueryParams {
+}
+export interface InputSchema {
+    actor: 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/graph/muteActorList.d.ts

@@ -0,0 +1,25 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+export interface QueryParams {
+}
+export interface InputSchema {
+    list: 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/graph/unmuteActor.d.ts

@@ -0,0 +1,25 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+export interface QueryParams {
+}
+export interface InputSchema {
+    actor: 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/graph/unmuteActorList.d.ts

@@ -0,0 +1,25 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+export interface QueryParams {
+}
+export interface InputSchema {
+    list: 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/moderation/defs.d.ts

@@ -0,0 +1,49 @@
+import { ValidationResult } from '@atproto/lexicon';
+import * as AppBskyActorDefs from '../actor/defs';
+import * as AppBskyRichtextFacet from '../richtext/facet';
+import * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs';
+import * as ComAtprotoModerationDefs from '../../../com/atproto/moderation/defs';
+export interface ModServiceView {
+    uri: string;
+    cid: string;
+    creator: AppBskyActorDefs.ProfileView;
+    description?: string;
+    descriptionFacets?: AppBskyRichtextFacet.Main[];
+    likeCount?: number;
+    viewer?: ModServiceViewerState;
+    indexedAt: string;
+    labels?: ComAtprotoLabelDefs.Label[];
+    [k: string]: unknown;
+}
+export declare function isModServiceView(v: unknown): v is ModServiceView;
+export declare function validateModServiceView(v: unknown): ValidationResult;
+export interface ModServiceViewDetailed {
+    uri: string;
+    cid: string;
+    creator: AppBskyActorDefs.ProfileView;
+    description?: string;
+    descriptionFacets?: AppBskyRichtextFacet.Main[];
+    policies: ModServicePolicies;
+    likeCount?: number;
+    viewer?: ModServiceViewerState;
+    indexedAt: string;
+    labels?: ComAtprotoLabelDefs.Label[];
+    [k: string]: unknown;
+}
+export declare function isModServiceViewDetailed(v: unknown): v is ModServiceViewDetailed;
+export declare function validateModServiceViewDetailed(v: unknown): ValidationResult;
+export interface ModServiceViewerState {
+    like?: string;
+    [k: string]: unknown;
+}
+export declare function isModServiceViewerState(v: unknown): v is ModServiceViewerState;
+export declare function validateModServiceViewerState(v: unknown): ValidationResult;
+export interface ModServicePolicies {
+    description?: string;
+    descriptionFacets?: AppBskyRichtextFacet.Main[];
+    reportReasons: ComAtprotoModerationDefs.ReasonType[];
+    labelValues: ComAtprotoLabelDefs.LabelValue[];
+    [k: string]: unknown;
+}
+export declare function isModServicePolicies(v: unknown): v is ModServicePolicies;
+export declare function validateModServicePolicies(v: unknown): ValidationResult;

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

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