@atproto/ozone 0.0.2 → 0.0.4

package/dist/lexicon/index.d.ts

@@ -1,5 +1,7 @@
 import { Server as XrpcServer, Options as XrpcOptions, AuthVerifier, StreamAuthVerifier } from '@atproto/xrpc-server';
+import * as ComAtprotoAdminCreateCommunicationTemplate from './types/com/atproto/admin/createCommunicationTemplate';
 import * as ComAtprotoAdminDeleteAccount from './types/com/atproto/admin/deleteAccount';
+import * as ComAtprotoAdminDeleteCommunicationTemplate from './types/com/atproto/admin/deleteCommunicationTemplate';
 import * as ComAtprotoAdminDisableAccountInvites from './types/com/atproto/admin/disableAccountInvites';
 import * as ComAtprotoAdminDisableInviteCodes from './types/com/atproto/admin/disableInviteCodes';
 import * as ComAtprotoAdminEmitModerationEvent from './types/com/atproto/admin/emitModerationEvent';
@@ -11,12 +13,14 @@ import * as ComAtprotoAdminGetModerationEvent from './types/com/atproto/admin/ge
 import * as ComAtprotoAdminGetRecord from './types/com/atproto/admin/getRecord';
 import * as ComAtprotoAdminGetRepo from './types/com/atproto/admin/getRepo';
 import * as ComAtprotoAdminGetSubjectStatus from './types/com/atproto/admin/getSubjectStatus';
+import * as ComAtprotoAdminListCommunicationTemplates from './types/com/atproto/admin/listCommunicationTemplates';
 import * as ComAtprotoAdminQueryModerationEvents from './types/com/atproto/admin/queryModerationEvents';
 import * as ComAtprotoAdminQueryModerationStatuses from './types/com/atproto/admin/queryModerationStatuses';
 import * as ComAtprotoAdminSearchRepos from './types/com/atproto/admin/searchRepos';
 import * as ComAtprotoAdminSendEmail from './types/com/atproto/admin/sendEmail';
 import * as ComAtprotoAdminUpdateAccountEmail from './types/com/atproto/admin/updateAccountEmail';
 import * as ComAtprotoAdminUpdateAccountHandle from './types/com/atproto/admin/updateAccountHandle';
+import * as ComAtprotoAdminUpdateCommunicationTemplate from './types/com/atproto/admin/updateCommunicationTemplate';
 import * as ComAtprotoAdminUpdateSubjectStatus from './types/com/atproto/admin/updateSubjectStatus';
 import * as ComAtprotoIdentityResolveHandle from './types/com/atproto/identity/resolveHandle';
 import * as ComAtprotoIdentityUpdateHandle from './types/com/atproto/identity/updateHandle';
@@ -158,7 +162,9 @@ export declare class ComAtprotoNS {
 export declare class ComAtprotoAdminNS {
     _server: Server;
     constructor(server: Server);
+    createCommunicationTemplate<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminCreateCommunicationTemplate.Handler<ExtractAuth<AV>>, ComAtprotoAdminCreateCommunicationTemplate.HandlerReqCtx<ExtractAuth<AV>>>): void;
     deleteAccount<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminDeleteAccount.Handler<ExtractAuth<AV>>, ComAtprotoAdminDeleteAccount.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    deleteCommunicationTemplate<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminDeleteCommunicationTemplate.Handler<ExtractAuth<AV>>, ComAtprotoAdminDeleteCommunicationTemplate.HandlerReqCtx<ExtractAuth<AV>>>): void;
     disableAccountInvites<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminDisableAccountInvites.Handler<ExtractAuth<AV>>, ComAtprotoAdminDisableAccountInvites.HandlerReqCtx<ExtractAuth<AV>>>): void;
     disableInviteCodes<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminDisableInviteCodes.Handler<ExtractAuth<AV>>, ComAtprotoAdminDisableInviteCodes.HandlerReqCtx<ExtractAuth<AV>>>): void;
     emitModerationEvent<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminEmitModerationEvent.Handler<ExtractAuth<AV>>, ComAtprotoAdminEmitModerationEvent.HandlerReqCtx<ExtractAuth<AV>>>): void;
@@ -170,12 +176,14 @@ export declare class ComAtprotoAdminNS {
     getRecord<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminGetRecord.Handler<ExtractAuth<AV>>, ComAtprotoAdminGetRecord.HandlerReqCtx<ExtractAuth<AV>>>): void;
     getRepo<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminGetRepo.Handler<ExtractAuth<AV>>, ComAtprotoAdminGetRepo.HandlerReqCtx<ExtractAuth<AV>>>): void;
     getSubjectStatus<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminGetSubjectStatus.Handler<ExtractAuth<AV>>, ComAtprotoAdminGetSubjectStatus.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    listCommunicationTemplates<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminListCommunicationTemplates.Handler<ExtractAuth<AV>>, ComAtprotoAdminListCommunicationTemplates.HandlerReqCtx<ExtractAuth<AV>>>): void;
     queryModerationEvents<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminQueryModerationEvents.Handler<ExtractAuth<AV>>, ComAtprotoAdminQueryModerationEvents.HandlerReqCtx<ExtractAuth<AV>>>): void;
     queryModerationStatuses<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminQueryModerationStatuses.Handler<ExtractAuth<AV>>, ComAtprotoAdminQueryModerationStatuses.HandlerReqCtx<ExtractAuth<AV>>>): void;
     searchRepos<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminSearchRepos.Handler<ExtractAuth<AV>>, ComAtprotoAdminSearchRepos.HandlerReqCtx<ExtractAuth<AV>>>): void;
     sendEmail<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminSendEmail.Handler<ExtractAuth<AV>>, ComAtprotoAdminSendEmail.HandlerReqCtx<ExtractAuth<AV>>>): void;
     updateAccountEmail<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminUpdateAccountEmail.Handler<ExtractAuth<AV>>, ComAtprotoAdminUpdateAccountEmail.HandlerReqCtx<ExtractAuth<AV>>>): void;
     updateAccountHandle<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminUpdateAccountHandle.Handler<ExtractAuth<AV>>, ComAtprotoAdminUpdateAccountHandle.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    updateCommunicationTemplate<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminUpdateCommunicationTemplate.Handler<ExtractAuth<AV>>, ComAtprotoAdminUpdateCommunicationTemplate.HandlerReqCtx<ExtractAuth<AV>>>): void;
     updateSubjectStatus<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminUpdateSubjectStatus.Handler<ExtractAuth<AV>>, ComAtprotoAdminUpdateSubjectStatus.HandlerReqCtx<ExtractAuth<AV>>>): void;
 }
 export declare class ComAtprotoIdentityNS {

package/dist/lexicon/lexicons.d.ts

@@ -1,5 +1,48 @@
 import { LexiconDoc, Lexicons } from '@atproto/lexicon';
 export declare const schemaDict: {
+    ComAtprotoAdminCreateCommunicationTemplate: {
+        lexicon: number;
+        id: string;
+        defs: {
+            main: {
+                type: string;
+                description: string;
+                input: {
+                    encoding: string;
+                    schema: {
+                        type: string;
+                        required: string[];
+                        properties: {
+                            name: {
+                                type: string;
+                                description: string;
+                            };
+                            contentMarkdown: {
+                                type: string;
+                                description: string;
+                            };
+                            subject: {
+                                type: string;
+                                description: string;
+                            };
+                            createdBy: {
+                                type: string;
+                                format: string;
+                                description: string;
+                            };
+                        };
+                    };
+                };
+                output: {
+                    encoding: string;
+                    schema: {
+                        type: string;
+                        ref: string;
+                    };
+                };
+            };
+        };
+    };
     ComAtprotoAdminDefs: {
         lexicon: number;
         id: string;
@@ -736,6 +779,43 @@ export declare const schemaDict: {
                     };
                 };
             };
+            communicationTemplateView: {
+                type: string;
+                required: string[];
+                properties: {
+                    id: {
+                        type: string;
+                    };
+                    name: {
+                        type: string;
+                        description: string;
+                    };
+                    subject: {
+                        type: string;
+                        description: string;
+                    };
+                    contentMarkdown: {
+                        type: string;
+                        description: string;
+                    };
+                    disabled: {
+                        type: string;
+                    };
+                    lastUpdatedBy: {
+                        type: string;
+                        format: string;
+                        description: string;
+                    };
+                    createdAt: {
+                        type: string;
+                        format: string;
+                    };
+                    updatedAt: {
+                        type: string;
+                        format: string;
+                    };
+                };
+            };
         };
     };
     ComAtprotoAdminDeleteAccount: {
@@ -761,6 +841,28 @@ export declare const schemaDict: {
             };
         };
     };
+    ComAtprotoAdminDeleteCommunicationTemplate: {
+        lexicon: number;
+        id: string;
+        defs: {
+            main: {
+                type: string;
+                description: string;
+                input: {
+                    encoding: string;
+                    schema: {
+                        type: string;
+                        required: string[];
+                        properties: {
+                            id: {
+                                type: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
     ComAtprotoAdminDisableAccountInvites: {
         lexicon: number;
         id: string;
@@ -1141,6 +1243,32 @@ export declare const schemaDict: {
             };
         };
     };
+    ComAtprotoAdminListCommunicationTemplates: {
+        lexicon: number;
+        id: string;
+        defs: {
+            main: {
+                type: string;
+                description: string;
+                output: {
+                    encoding: string;
+                    schema: {
+                        type: string;
+                        required: string[];
+                        properties: {
+                            communicationTemplates: {
+                                type: string;
+                                items: {
+                                    type: string;
+                                    ref: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
     ComAtprotoAdminQueryModerationEvents: {
         lexicon: number;
         id: string;
@@ -1472,6 +1600,56 @@ export declare const schemaDict: {
             };
         };
     };
+    ComAtprotoAdminUpdateCommunicationTemplate: {
+        lexicon: number;
+        id: string;
+        defs: {
+            main: {
+                type: string;
+                description: string;
+                input: {
+                    encoding: string;
+                    schema: {
+                        type: string;
+                        required: string[];
+                        properties: {
+                            id: {
+                                type: string;
+                                description: string;
+                            };
+                            name: {
+                                type: string;
+                                description: string;
+                            };
+                            contentMarkdown: {
+                                type: string;
+                                description: string;
+                            };
+                            subject: {
+                                type: string;
+                                description: string;
+                            };
+                            updatedBy: {
+                                type: string;
+                                format: string;
+                                description: string;
+                            };
+                            disabled: {
+                                type: string;
+                            };
+                        };
+                    };
+                };
+                output: {
+                    encoding: string;
+                    schema: {
+                        type: string;
+                        ref: string;
+                    };
+                };
+            };
+        };
+    };
     ComAtprotoAdminUpdateSubjectStatus: {
         lexicon: number;
         id: string;
@@ -7411,8 +7589,10 @@ export declare const schemaDict: {
 export declare const schemas: LexiconDoc[];
 export declare const lexicons: Lexicons;
 export declare const ids: {
+    ComAtprotoAdminCreateCommunicationTemplate: string;
     ComAtprotoAdminDefs: string;
     ComAtprotoAdminDeleteAccount: string;
+    ComAtprotoAdminDeleteCommunicationTemplate: string;
     ComAtprotoAdminDisableAccountInvites: string;
     ComAtprotoAdminDisableInviteCodes: string;
     ComAtprotoAdminEmitModerationEvent: string;
@@ -7424,12 +7604,14 @@ export declare const ids: {
     ComAtprotoAdminGetRecord: string;
     ComAtprotoAdminGetRepo: string;
     ComAtprotoAdminGetSubjectStatus: string;
+    ComAtprotoAdminListCommunicationTemplates: string;
     ComAtprotoAdminQueryModerationEvents: string;
     ComAtprotoAdminQueryModerationStatuses: string;
     ComAtprotoAdminSearchRepos: string;
     ComAtprotoAdminSendEmail: string;
     ComAtprotoAdminUpdateAccountEmail: string;
     ComAtprotoAdminUpdateAccountHandle: string;
+    ComAtprotoAdminUpdateCommunicationTemplate: string;
     ComAtprotoAdminUpdateSubjectStatus: string;
     ComAtprotoIdentityResolveHandle: string;
     ComAtprotoIdentityUpdateHandle: string;

package/dist/lexicon/types/{app/bsky/unspecced/getPopular.d.ts → com/atproto/admin/createCommunicationTemplate.d.ts}

@@ -1,18 +1,20 @@
 import express from 'express';
 import { HandlerAuth } from '@atproto/xrpc-server';
-import * as AppBskyFeedDefs from '../feed/defs';
+import * as ComAtprotoAdminDefs from './defs';
 export interface QueryParams {
-    includeNsfw: boolean;
-    limit: number;
-    cursor?: string;
 }
-export type InputSchema = undefined;
-export interface OutputSchema {
-    cursor?: string;
-    feed: AppBskyFeedDefs.FeedViewPost[];
+export interface InputSchema {
+    name: string;
+    contentMarkdown: string;
+    subject: string;
+    createdBy?: string;
     [k: string]: unknown;
 }
-export type HandlerInput = undefined;
+export type OutputSchema = ComAtprotoAdminDefs.CommunicationTemplateView;
+export interface HandlerInput {
+    encoding: 'application/json';
+    body: InputSchema;
+}
 export interface HandlerSuccess {
     encoding: 'application/json';
     body: OutputSchema;

package/dist/lexicon/types/com/atproto/admin/defs.d.ts

@@ -317,3 +317,16 @@ export interface ModEventEmail {
 }
 export declare function isModEventEmail(v: unknown): v is ModEventEmail;
 export declare function validateModEventEmail(v: unknown): ValidationResult;
+export interface CommunicationTemplateView {
+    id: string;
+    name: string;
+    subject?: string;
+    contentMarkdown: string;
+    disabled: boolean;
+    lastUpdatedBy: string;
+    createdAt: string;
+    updatedAt: string;
+    [k: string]: unknown;
+}
+export declare function isCommunicationTemplateView(v: unknown): v is CommunicationTemplateView;
+export declare function validateCommunicationTemplateView(v: unknown): ValidationResult;

package/dist/lexicon/types/com/atproto/admin/deleteCommunicationTemplate.d.ts

@@ -0,0 +1,25 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+export interface QueryParams {
+}
+export interface InputSchema {
+    id: 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/getServices.d.ts → com/atproto/admin/listCommunicationTemplates.d.ts}

@@ -1,12 +1,11 @@
 import express from 'express';
 import { HandlerAuth } from '@atproto/xrpc-server';
-import * as AppBskyModerationDefs from './defs';
+import * as ComAtprotoAdminDefs from './defs';
 export interface QueryParams {
-    dids: string[];
 }
 export type InputSchema = undefined;
 export interface OutputSchema {
-    views: AppBskyModerationDefs.ModServiceView[];
+    communicationTemplates: ComAtprotoAdminDefs.CommunicationTemplateView[];
     [k: string]: unknown;
 }
 export type HandlerInput = undefined;

package/dist/lexicon/types/{app/bsky/moderation/getService.d.ts → com/atproto/admin/updateCommunicationTemplate.d.ts}

@@ -1,12 +1,22 @@
 import express from 'express';
 import { HandlerAuth } from '@atproto/xrpc-server';
-import * as AppBskyModerationDefs from './defs';
+import * as ComAtprotoAdminDefs from './defs';
 export interface QueryParams {
-    did: string;
 }
-export type InputSchema = undefined;
-export type OutputSchema = AppBskyModerationDefs.ModServiceViewDetailed;
-export type HandlerInput = undefined;
+export interface InputSchema {
+    id: string;
+    name?: string;
+    contentMarkdown?: string;
+    subject?: string;
+    updatedBy?: string;
+    disabled?: boolean;
+    [k: string]: unknown;
+}
+export type OutputSchema = ComAtprotoAdminDefs.CommunicationTemplateView;
+export interface HandlerInput {
+    encoding: 'application/json';
+    body: InputSchema;
+}
 export interface HandlerSuccess {
     encoding: 'application/json';
     body: OutputSchema;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/ozone",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "license": "MIT",
   "description": "Backend service for moderating the Bluesky network.",
   "keywords": [
@@ -30,13 +30,13 @@
     "pino-http": "^8.2.1",
     "typed-emitter": "^2.1.0",
     "uint8arrays": "3.0.0",
+    "@atproto/api": "^0.9.2",
     "@atproto/common": "^0.3.3",
+    "@atproto/crypto": "^0.3.0",
     "@atproto/syntax": "^0.1.5",
     "@atproto/identity": "^0.3.2",
     "@atproto/lexicon": "^0.3.1",
-    "@atproto/xrpc-server": "^0.4.2",
-    "@atproto/crypto": "^0.3.0",
-    "@atproto/api": "^0.9.0"
+    "@atproto/xrpc-server": "^0.4.2"
   },
   "devDependencies": {
     "@did-plc/server": "^0.0.1",
@@ -46,11 +46,11 @@
     "@types/pg": "^8.6.6",
     "@types/qs": "^6.9.7",
     "axios": "^0.27.2",
+    "@atproto/api": "^0.9.2",
+    "@atproto/dev-env": "^0.2.25",
     "@atproto/lex-cli": "^0.3.0",
-    "@atproto/api": "^0.9.0",
-    "@atproto/xrpc": "^0.4.1",
-    "@atproto/dev-env": "^0.2.23",
-    "@atproto/pds": "^0.3.11"
+    "@atproto/pds": "^0.3.13",
+    "@atproto/xrpc": "^0.4.1"
   },
   "scripts": {
     "codegen": "lex gen-server ./src/lexicon ../../lexicons/com/atproto/*/* ../../lexicons/app/bsky/*/*",

package/src/api/admin/createCommunicationTemplate.ts

@@ -0,0 +1,37 @@
+import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
+import { Server } from '../../lexicon'
+import AppContext from '../../context'
+
+export default function (server: Server, ctx: AppContext) {
+  server.com.atproto.admin.createCommunicationTemplate({
+    auth: ctx.roleVerifier,
+    handler: async ({ input, auth }) => {
+      const access = auth.credentials
+      const db = ctx.db
+      const { createdBy, ...template } = input.body
+
+      if (!access.admin) {
+        throw new AuthRequiredError(
+          'Must be an admin to create a communication template',
+        )
+      }
+
+      // Once auth starts providing us with the caller's DID, we can get rid of this check
+      if (!createdBy) {
+        throw new InvalidRequestError('createdBy field is required')
+      }
+
+      const communicationTemplate = ctx.communicationTemplateService(db)
+      const newTemplate = await communicationTemplate.create({
+        ...template,
+        disabled: false,
+        lastUpdatedBy: createdBy,
+      })
+
+      return {
+        encoding: 'application/json',
+        body: communicationTemplate.view(newTemplate),
+      }
+    },
+  })
+}

package/src/api/admin/deleteCommunicationTemplate.ts

@@ -0,0 +1,23 @@
+import { AuthRequiredError } from '@atproto/xrpc-server'
+import { Server } from '../../lexicon'
+import AppContext from '../../context'
+
+export default function (server: Server, ctx: AppContext) {
+  server.com.atproto.admin.deleteCommunicationTemplate({
+    auth: ctx.roleVerifier,
+    handler: async ({ input, auth }) => {
+      const access = auth.credentials
+      const db = ctx.db
+      const { id } = input.body
+
+      if (!access.admin) {
+        throw new AuthRequiredError(
+          'Must be an admin to delete a communication template',
+        )
+      }
+
+      const communicationTemplate = ctx.communicationTemplateService(db)
+      await communicationTemplate.delete(Number(id))
+    },
+  })
+}

package/src/api/admin/listCommunicationTemplates.ts

@@ -0,0 +1,31 @@
+import { AuthRequiredError } from '@atproto/xrpc-server'
+import { Server } from '../../lexicon'
+import AppContext from '../../context'
+
+export default function (server: Server, ctx: AppContext) {
+  server.com.atproto.admin.listCommunicationTemplates({
+    auth: ctx.roleVerifier,
+    handler: async ({ auth }) => {
+      const access = auth.credentials
+      const db = ctx.db
+
+      if (!access.moderator) {
+        throw new AuthRequiredError(
+          'Must be a full moderator to view list of communication template',
+        )
+      }
+
+      const communicationTemplate = ctx.communicationTemplateService(db)
+      const list = await communicationTemplate.list()
+
+      return {
+        encoding: 'application/json',
+        body: {
+          communicationTemplates: list.map((item) =>
+            communicationTemplate.view(item),
+          ),
+        },
+      }
+    },
+  })
+}

package/src/api/admin/updateCommunicationTemplate.ts

@@ -0,0 +1,40 @@
+import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
+import { Server } from '../../lexicon'
+import AppContext from '../../context'
+
+export default function (server: Server, ctx: AppContext) {
+  server.com.atproto.admin.updateCommunicationTemplate({
+    auth: ctx.roleVerifier,
+    handler: async ({ input, auth }) => {
+      const access = auth.credentials
+      const db = ctx.db
+      const { id, updatedBy, ...template } = input.body
+
+      if (!access.admin) {
+        throw new AuthRequiredError(
+          'Must be an admin to update a communication template',
+        )
+      }
+
+      // Once auth starts providing us with the caller's DID, we can get rid of this check
+      if (!updatedBy) {
+        throw new InvalidRequestError('updatedBy field is required')
+      }
+
+      if (!Object.keys(template).length) {
+        throw new InvalidRequestError('Missing update data in request body')
+      }
+
+      const communicationTemplate = ctx.communicationTemplateService(db)
+      const updatedTemplate = await communicationTemplate.update(Number(id), {
+        ...template,
+        lastUpdatedBy: updatedBy,
+      })
+
+      return {
+        encoding: 'application/json',
+        body: communicationTemplate.view(updatedTemplate),
+      }
+    },
+  })
+}

package/src/api/index.ts

@@ -9,6 +9,10 @@ import queryModerationStatuses from './admin/queryModerationStatuses'
 import queryModerationEvents from './admin/queryModerationEvents'
 import getModerationEvent from './admin/getModerationEvent'
 import fetchLabels from './temp/fetchLabels'
+import createCommunicationTemplate from './admin/createCommunicationTemplate'
+import updateCommunicationTemplate from './admin/updateCommunicationTemplate'
+import deleteCommunicationTemplate from './admin/deleteCommunicationTemplate'
+import listCommunicationTemplates from './admin/listCommunicationTemplates'
 
 export * as health from './health'
 
@@ -24,5 +28,9 @@ export default function (server: Server, ctx: AppContext) {
   queryModerationEvents(server, ctx)
   queryModerationStatuses(server, ctx)
   fetchLabels(server, ctx)
+  listCommunicationTemplates(server, ctx)
+  createCommunicationTemplate(server, ctx)
+  updateCommunicationTemplate(server, ctx)
+  deleteCommunicationTemplate(server, ctx)
   return server
 }