@devvit/protos 0.11.0-next-2024-07-24-1be38cc96.0 → 0.11.0-next-2024-07-25-1378e6e47.0

package/types/devvit/plugin/redditapi/wiki/wiki_svc.twirp.js

@@ -0,0 +1,685 @@
+import { TwirpServer, TwirpError, TwirpErrorCode, TwirpContentType, chainInterceptors, } from 'twirp-ts';
+import { GetWikiPagesRequest, GetWikiPagesResponse, GetWikiPageRequest, GetWikiPageResponse, EditWikiPageRequest, HideWikiPageRevisionRequest, HideWikiPageRevisionResponse, GetWikiPageRevisionsRequest, WikiPageRevisionListing, GetWikiRevisionsRequest, RevertWikiPageRequest, GetWikiPageSettingsRequest, WikiPageSettings, UpdateWikiPageSettingsRequest, AllowEditorRequest, } from './wiki_msg.js';
+import { Empty } from '../../../../google/protobuf/empty.js';
+export var WikiMethod;
+(function (WikiMethod) {
+    WikiMethod["GetWikiPages"] = "GetWikiPages";
+    WikiMethod["GetWikiPage"] = "GetWikiPage";
+    WikiMethod["EditWikiPage"] = "EditWikiPage";
+    WikiMethod["HideWikiPageRevision"] = "HideWikiPageRevision";
+    WikiMethod["GetWikiPageRevisions"] = "GetWikiPageRevisions";
+    WikiMethod["GetWikiRevisions"] = "GetWikiRevisions";
+    WikiMethod["RevertWikiPage"] = "RevertWikiPage";
+    WikiMethod["GetWikiPageSettings"] = "GetWikiPageSettings";
+    WikiMethod["UpdateWikiPageSettings"] = "UpdateWikiPageSettings";
+    WikiMethod["AllowEditor"] = "AllowEditor";
+})(WikiMethod || (WikiMethod = {}));
+export const WikiMethodList = [
+    WikiMethod.GetWikiPages,
+    WikiMethod.GetWikiPage,
+    WikiMethod.EditWikiPage,
+    WikiMethod.HideWikiPageRevision,
+    WikiMethod.GetWikiPageRevisions,
+    WikiMethod.GetWikiRevisions,
+    WikiMethod.RevertWikiPage,
+    WikiMethod.GetWikiPageSettings,
+    WikiMethod.UpdateWikiPageSettings,
+    WikiMethod.AllowEditor,
+];
+export function createWikiServer(service) {
+    return new TwirpServer({
+        service,
+        packageName: 'devvit.plugin.redditapi.wiki',
+        serviceName: 'Wiki',
+        methodList: WikiMethodList,
+        matchRoute: matchWikiRoute,
+    });
+}
+function matchWikiRoute(method, events) {
+    switch (method) {
+        case 'GetWikiPages':
+            return async (ctx, service, data, interceptors) => {
+                ctx = { ...ctx, methodName: 'GetWikiPages' };
+                await events.onMatch(ctx);
+                return handleWikiGetWikiPagesRequest(ctx, service, data, interceptors);
+            };
+        case 'GetWikiPage':
+            return async (ctx, service, data, interceptors) => {
+                ctx = { ...ctx, methodName: 'GetWikiPage' };
+                await events.onMatch(ctx);
+                return handleWikiGetWikiPageRequest(ctx, service, data, interceptors);
+            };
+        case 'EditWikiPage':
+            return async (ctx, service, data, interceptors) => {
+                ctx = { ...ctx, methodName: 'EditWikiPage' };
+                await events.onMatch(ctx);
+                return handleWikiEditWikiPageRequest(ctx, service, data, interceptors);
+            };
+        case 'HideWikiPageRevision':
+            return async (ctx, service, data, interceptors) => {
+                ctx = { ...ctx, methodName: 'HideWikiPageRevision' };
+                await events.onMatch(ctx);
+                return handleWikiHideWikiPageRevisionRequest(ctx, service, data, interceptors);
+            };
+        case 'GetWikiPageRevisions':
+            return async (ctx, service, data, interceptors) => {
+                ctx = { ...ctx, methodName: 'GetWikiPageRevisions' };
+                await events.onMatch(ctx);
+                return handleWikiGetWikiPageRevisionsRequest(ctx, service, data, interceptors);
+            };
+        case 'GetWikiRevisions':
+            return async (ctx, service, data, interceptors) => {
+                ctx = { ...ctx, methodName: 'GetWikiRevisions' };
+                await events.onMatch(ctx);
+                return handleWikiGetWikiRevisionsRequest(ctx, service, data, interceptors);
+            };
+        case 'RevertWikiPage':
+            return async (ctx, service, data, interceptors) => {
+                ctx = { ...ctx, methodName: 'RevertWikiPage' };
+                await events.onMatch(ctx);
+                return handleWikiRevertWikiPageRequest(ctx, service, data, interceptors);
+            };
+        case 'GetWikiPageSettings':
+            return async (ctx, service, data, interceptors) => {
+                ctx = { ...ctx, methodName: 'GetWikiPageSettings' };
+                await events.onMatch(ctx);
+                return handleWikiGetWikiPageSettingsRequest(ctx, service, data, interceptors);
+            };
+        case 'UpdateWikiPageSettings':
+            return async (ctx, service, data, interceptors) => {
+                ctx = { ...ctx, methodName: 'UpdateWikiPageSettings' };
+                await events.onMatch(ctx);
+                return handleWikiUpdateWikiPageSettingsRequest(ctx, service, data, interceptors);
+            };
+        case 'AllowEditor':
+            return async (ctx, service, data, interceptors) => {
+                ctx = { ...ctx, methodName: 'AllowEditor' };
+                await events.onMatch(ctx);
+                return handleWikiAllowEditorRequest(ctx, service, data, interceptors);
+            };
+        default:
+            events.onNotFound();
+            const msg = `no handler found`;
+            throw new TwirpError(TwirpErrorCode.BadRoute, msg);
+    }
+}
+function handleWikiGetWikiPagesRequest(ctx, service, data, interceptors) {
+    switch (ctx.contentType) {
+        case TwirpContentType.JSON:
+            return handleWikiGetWikiPagesJSON(ctx, service, data, interceptors);
+        case TwirpContentType.Protobuf:
+            return handleWikiGetWikiPagesProtobuf(ctx, service, data, interceptors);
+        default:
+            const msg = 'unexpected Content-Type';
+            throw new TwirpError(TwirpErrorCode.BadRoute, msg);
+    }
+}
+function handleWikiGetWikiPageRequest(ctx, service, data, interceptors) {
+    switch (ctx.contentType) {
+        case TwirpContentType.JSON:
+            return handleWikiGetWikiPageJSON(ctx, service, data, interceptors);
+        case TwirpContentType.Protobuf:
+            return handleWikiGetWikiPageProtobuf(ctx, service, data, interceptors);
+        default:
+            const msg = 'unexpected Content-Type';
+            throw new TwirpError(TwirpErrorCode.BadRoute, msg);
+    }
+}
+function handleWikiEditWikiPageRequest(ctx, service, data, interceptors) {
+    switch (ctx.contentType) {
+        case TwirpContentType.JSON:
+            return handleWikiEditWikiPageJSON(ctx, service, data, interceptors);
+        case TwirpContentType.Protobuf:
+            return handleWikiEditWikiPageProtobuf(ctx, service, data, interceptors);
+        default:
+            const msg = 'unexpected Content-Type';
+            throw new TwirpError(TwirpErrorCode.BadRoute, msg);
+    }
+}
+function handleWikiHideWikiPageRevisionRequest(ctx, service, data, interceptors) {
+    switch (ctx.contentType) {
+        case TwirpContentType.JSON:
+            return handleWikiHideWikiPageRevisionJSON(ctx, service, data, interceptors);
+        case TwirpContentType.Protobuf:
+            return handleWikiHideWikiPageRevisionProtobuf(ctx, service, data, interceptors);
+        default:
+            const msg = 'unexpected Content-Type';
+            throw new TwirpError(TwirpErrorCode.BadRoute, msg);
+    }
+}
+function handleWikiGetWikiPageRevisionsRequest(ctx, service, data, interceptors) {
+    switch (ctx.contentType) {
+        case TwirpContentType.JSON:
+            return handleWikiGetWikiPageRevisionsJSON(ctx, service, data, interceptors);
+        case TwirpContentType.Protobuf:
+            return handleWikiGetWikiPageRevisionsProtobuf(ctx, service, data, interceptors);
+        default:
+            const msg = 'unexpected Content-Type';
+            throw new TwirpError(TwirpErrorCode.BadRoute, msg);
+    }
+}
+function handleWikiGetWikiRevisionsRequest(ctx, service, data, interceptors) {
+    switch (ctx.contentType) {
+        case TwirpContentType.JSON:
+            return handleWikiGetWikiRevisionsJSON(ctx, service, data, interceptors);
+        case TwirpContentType.Protobuf:
+            return handleWikiGetWikiRevisionsProtobuf(ctx, service, data, interceptors);
+        default:
+            const msg = 'unexpected Content-Type';
+            throw new TwirpError(TwirpErrorCode.BadRoute, msg);
+    }
+}
+function handleWikiRevertWikiPageRequest(ctx, service, data, interceptors) {
+    switch (ctx.contentType) {
+        case TwirpContentType.JSON:
+            return handleWikiRevertWikiPageJSON(ctx, service, data, interceptors);
+        case TwirpContentType.Protobuf:
+            return handleWikiRevertWikiPageProtobuf(ctx, service, data, interceptors);
+        default:
+            const msg = 'unexpected Content-Type';
+            throw new TwirpError(TwirpErrorCode.BadRoute, msg);
+    }
+}
+function handleWikiGetWikiPageSettingsRequest(ctx, service, data, interceptors) {
+    switch (ctx.contentType) {
+        case TwirpContentType.JSON:
+            return handleWikiGetWikiPageSettingsJSON(ctx, service, data, interceptors);
+        case TwirpContentType.Protobuf:
+            return handleWikiGetWikiPageSettingsProtobuf(ctx, service, data, interceptors);
+        default:
+            const msg = 'unexpected Content-Type';
+            throw new TwirpError(TwirpErrorCode.BadRoute, msg);
+    }
+}
+function handleWikiUpdateWikiPageSettingsRequest(ctx, service, data, interceptors) {
+    switch (ctx.contentType) {
+        case TwirpContentType.JSON:
+            return handleWikiUpdateWikiPageSettingsJSON(ctx, service, data, interceptors);
+        case TwirpContentType.Protobuf:
+            return handleWikiUpdateWikiPageSettingsProtobuf(ctx, service, data, interceptors);
+        default:
+            const msg = 'unexpected Content-Type';
+            throw new TwirpError(TwirpErrorCode.BadRoute, msg);
+    }
+}
+function handleWikiAllowEditorRequest(ctx, service, data, interceptors) {
+    switch (ctx.contentType) {
+        case TwirpContentType.JSON:
+            return handleWikiAllowEditorJSON(ctx, service, data, interceptors);
+        case TwirpContentType.Protobuf:
+            return handleWikiAllowEditorProtobuf(ctx, service, data, interceptors);
+        default:
+            const msg = 'unexpected Content-Type';
+            throw new TwirpError(TwirpErrorCode.BadRoute, msg);
+    }
+}
+async function handleWikiGetWikiPagesJSON(ctx, service, data, interceptors) {
+    let request;
+    let response;
+    try {
+        const body = JSON.parse(data.toString() || '{}');
+        request = GetWikiPagesRequest.fromJSON(body);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            const msg = 'the json request could not be decoded';
+            throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true);
+        }
+    }
+    if (interceptors && interceptors.length > 0) {
+        const interceptor = chainInterceptors(...interceptors);
+        response = await interceptor(ctx, request, (ctx, inputReq) => {
+            return service.GetWikiPages(ctx, inputReq);
+        });
+    }
+    else {
+        response = await service.GetWikiPages(ctx, request);
+    }
+    return JSON.stringify(GetWikiPagesResponse.toJSON(response));
+}
+async function handleWikiGetWikiPageJSON(ctx, service, data, interceptors) {
+    let request;
+    let response;
+    try {
+        const body = JSON.parse(data.toString() || '{}');
+        request = GetWikiPageRequest.fromJSON(body);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            const msg = 'the json request could not be decoded';
+            throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true);
+        }
+    }
+    if (interceptors && interceptors.length > 0) {
+        const interceptor = chainInterceptors(...interceptors);
+        response = await interceptor(ctx, request, (ctx, inputReq) => {
+            return service.GetWikiPage(ctx, inputReq);
+        });
+    }
+    else {
+        response = await service.GetWikiPage(ctx, request);
+    }
+    return JSON.stringify(GetWikiPageResponse.toJSON(response));
+}
+async function handleWikiEditWikiPageJSON(ctx, service, data, interceptors) {
+    let request;
+    let response;
+    try {
+        const body = JSON.parse(data.toString() || '{}');
+        request = EditWikiPageRequest.fromJSON(body);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            const msg = 'the json request could not be decoded';
+            throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true);
+        }
+    }
+    if (interceptors && interceptors.length > 0) {
+        const interceptor = chainInterceptors(...interceptors);
+        response = await interceptor(ctx, request, (ctx, inputReq) => {
+            return service.EditWikiPage(ctx, inputReq);
+        });
+    }
+    else {
+        response = await service.EditWikiPage(ctx, request);
+    }
+    return JSON.stringify(Empty.toJSON(response));
+}
+async function handleWikiHideWikiPageRevisionJSON(ctx, service, data, interceptors) {
+    let request;
+    let response;
+    try {
+        const body = JSON.parse(data.toString() || '{}');
+        request = HideWikiPageRevisionRequest.fromJSON(body);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            const msg = 'the json request could not be decoded';
+            throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true);
+        }
+    }
+    if (interceptors && interceptors.length > 0) {
+        const interceptor = chainInterceptors(...interceptors);
+        response = await interceptor(ctx, request, (ctx, inputReq) => {
+            return service.HideWikiPageRevision(ctx, inputReq);
+        });
+    }
+    else {
+        response = await service.HideWikiPageRevision(ctx, request);
+    }
+    return JSON.stringify(HideWikiPageRevisionResponse.toJSON(response));
+}
+async function handleWikiGetWikiPageRevisionsJSON(ctx, service, data, interceptors) {
+    let request;
+    let response;
+    try {
+        const body = JSON.parse(data.toString() || '{}');
+        request = GetWikiPageRevisionsRequest.fromJSON(body);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            const msg = 'the json request could not be decoded';
+            throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true);
+        }
+    }
+    if (interceptors && interceptors.length > 0) {
+        const interceptor = chainInterceptors(...interceptors);
+        response = await interceptor(ctx, request, (ctx, inputReq) => {
+            return service.GetWikiPageRevisions(ctx, inputReq);
+        });
+    }
+    else {
+        response = await service.GetWikiPageRevisions(ctx, request);
+    }
+    return JSON.stringify(WikiPageRevisionListing.toJSON(response));
+}
+async function handleWikiGetWikiRevisionsJSON(ctx, service, data, interceptors) {
+    let request;
+    let response;
+    try {
+        const body = JSON.parse(data.toString() || '{}');
+        request = GetWikiRevisionsRequest.fromJSON(body);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            const msg = 'the json request could not be decoded';
+            throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true);
+        }
+    }
+    if (interceptors && interceptors.length > 0) {
+        const interceptor = chainInterceptors(...interceptors);
+        response = await interceptor(ctx, request, (ctx, inputReq) => {
+            return service.GetWikiRevisions(ctx, inputReq);
+        });
+    }
+    else {
+        response = await service.GetWikiRevisions(ctx, request);
+    }
+    return JSON.stringify(WikiPageRevisionListing.toJSON(response));
+}
+async function handleWikiRevertWikiPageJSON(ctx, service, data, interceptors) {
+    let request;
+    let response;
+    try {
+        const body = JSON.parse(data.toString() || '{}');
+        request = RevertWikiPageRequest.fromJSON(body);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            const msg = 'the json request could not be decoded';
+            throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true);
+        }
+    }
+    if (interceptors && interceptors.length > 0) {
+        const interceptor = chainInterceptors(...interceptors);
+        response = await interceptor(ctx, request, (ctx, inputReq) => {
+            return service.RevertWikiPage(ctx, inputReq);
+        });
+    }
+    else {
+        response = await service.RevertWikiPage(ctx, request);
+    }
+    return JSON.stringify(Empty.toJSON(response));
+}
+async function handleWikiGetWikiPageSettingsJSON(ctx, service, data, interceptors) {
+    let request;
+    let response;
+    try {
+        const body = JSON.parse(data.toString() || '{}');
+        request = GetWikiPageSettingsRequest.fromJSON(body);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            const msg = 'the json request could not be decoded';
+            throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true);
+        }
+    }
+    if (interceptors && interceptors.length > 0) {
+        const interceptor = chainInterceptors(...interceptors);
+        response = await interceptor(ctx, request, (ctx, inputReq) => {
+            return service.GetWikiPageSettings(ctx, inputReq);
+        });
+    }
+    else {
+        response = await service.GetWikiPageSettings(ctx, request);
+    }
+    return JSON.stringify(WikiPageSettings.toJSON(response));
+}
+async function handleWikiUpdateWikiPageSettingsJSON(ctx, service, data, interceptors) {
+    let request;
+    let response;
+    try {
+        const body = JSON.parse(data.toString() || '{}');
+        request = UpdateWikiPageSettingsRequest.fromJSON(body);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            const msg = 'the json request could not be decoded';
+            throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true);
+        }
+    }
+    if (interceptors && interceptors.length > 0) {
+        const interceptor = chainInterceptors(...interceptors);
+        response = await interceptor(ctx, request, (ctx, inputReq) => {
+            return service.UpdateWikiPageSettings(ctx, inputReq);
+        });
+    }
+    else {
+        response = await service.UpdateWikiPageSettings(ctx, request);
+    }
+    return JSON.stringify(WikiPageSettings.toJSON(response));
+}
+async function handleWikiAllowEditorJSON(ctx, service, data, interceptors) {
+    let request;
+    let response;
+    try {
+        const body = JSON.parse(data.toString() || '{}');
+        request = AllowEditorRequest.fromJSON(body);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            const msg = 'the json request could not be decoded';
+            throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true);
+        }
+    }
+    if (interceptors && interceptors.length > 0) {
+        const interceptor = chainInterceptors(...interceptors);
+        response = await interceptor(ctx, request, (ctx, inputReq) => {
+            return service.AllowEditor(ctx, inputReq);
+        });
+    }
+    else {
+        response = await service.AllowEditor(ctx, request);
+    }
+    return JSON.stringify(Empty.toJSON(response));
+}
+async function handleWikiGetWikiPagesProtobuf(ctx, service, data, interceptors) {
+    let request;
+    let response;
+    try {
+        request = GetWikiPagesRequest.decode(data);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            const msg = 'the protobuf request could not be decoded';
+            throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true);
+        }
+    }
+    if (interceptors && interceptors.length > 0) {
+        const interceptor = chainInterceptors(...interceptors);
+        response = await interceptor(ctx, request, (ctx, inputReq) => {
+            return service.GetWikiPages(ctx, inputReq);
+        });
+    }
+    else {
+        response = await service.GetWikiPages(ctx, request);
+    }
+    return Buffer.from(GetWikiPagesResponse.encode(response).finish());
+}
+async function handleWikiGetWikiPageProtobuf(ctx, service, data, interceptors) {
+    let request;
+    let response;
+    try {
+        request = GetWikiPageRequest.decode(data);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            const msg = 'the protobuf request could not be decoded';
+            throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true);
+        }
+    }
+    if (interceptors && interceptors.length > 0) {
+        const interceptor = chainInterceptors(...interceptors);
+        response = await interceptor(ctx, request, (ctx, inputReq) => {
+            return service.GetWikiPage(ctx, inputReq);
+        });
+    }
+    else {
+        response = await service.GetWikiPage(ctx, request);
+    }
+    return Buffer.from(GetWikiPageResponse.encode(response).finish());
+}
+async function handleWikiEditWikiPageProtobuf(ctx, service, data, interceptors) {
+    let request;
+    let response;
+    try {
+        request = EditWikiPageRequest.decode(data);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            const msg = 'the protobuf request could not be decoded';
+            throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true);
+        }
+    }
+    if (interceptors && interceptors.length > 0) {
+        const interceptor = chainInterceptors(...interceptors);
+        response = await interceptor(ctx, request, (ctx, inputReq) => {
+            return service.EditWikiPage(ctx, inputReq);
+        });
+    }
+    else {
+        response = await service.EditWikiPage(ctx, request);
+    }
+    return Buffer.from(Empty.encode(response).finish());
+}
+async function handleWikiHideWikiPageRevisionProtobuf(ctx, service, data, interceptors) {
+    let request;
+    let response;
+    try {
+        request = HideWikiPageRevisionRequest.decode(data);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            const msg = 'the protobuf request could not be decoded';
+            throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true);
+        }
+    }
+    if (interceptors && interceptors.length > 0) {
+        const interceptor = chainInterceptors(...interceptors);
+        response = await interceptor(ctx, request, (ctx, inputReq) => {
+            return service.HideWikiPageRevision(ctx, inputReq);
+        });
+    }
+    else {
+        response = await service.HideWikiPageRevision(ctx, request);
+    }
+    return Buffer.from(HideWikiPageRevisionResponse.encode(response).finish());
+}
+async function handleWikiGetWikiPageRevisionsProtobuf(ctx, service, data, interceptors) {
+    let request;
+    let response;
+    try {
+        request = GetWikiPageRevisionsRequest.decode(data);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            const msg = 'the protobuf request could not be decoded';
+            throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true);
+        }
+    }
+    if (interceptors && interceptors.length > 0) {
+        const interceptor = chainInterceptors(...interceptors);
+        response = await interceptor(ctx, request, (ctx, inputReq) => {
+            return service.GetWikiPageRevisions(ctx, inputReq);
+        });
+    }
+    else {
+        response = await service.GetWikiPageRevisions(ctx, request);
+    }
+    return Buffer.from(WikiPageRevisionListing.encode(response).finish());
+}
+async function handleWikiGetWikiRevisionsProtobuf(ctx, service, data, interceptors) {
+    let request;
+    let response;
+    try {
+        request = GetWikiRevisionsRequest.decode(data);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            const msg = 'the protobuf request could not be decoded';
+            throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true);
+        }
+    }
+    if (interceptors && interceptors.length > 0) {
+        const interceptor = chainInterceptors(...interceptors);
+        response = await interceptor(ctx, request, (ctx, inputReq) => {
+            return service.GetWikiRevisions(ctx, inputReq);
+        });
+    }
+    else {
+        response = await service.GetWikiRevisions(ctx, request);
+    }
+    return Buffer.from(WikiPageRevisionListing.encode(response).finish());
+}
+async function handleWikiRevertWikiPageProtobuf(ctx, service, data, interceptors) {
+    let request;
+    let response;
+    try {
+        request = RevertWikiPageRequest.decode(data);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            const msg = 'the protobuf request could not be decoded';
+            throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true);
+        }
+    }
+    if (interceptors && interceptors.length > 0) {
+        const interceptor = chainInterceptors(...interceptors);
+        response = await interceptor(ctx, request, (ctx, inputReq) => {
+            return service.RevertWikiPage(ctx, inputReq);
+        });
+    }
+    else {
+        response = await service.RevertWikiPage(ctx, request);
+    }
+    return Buffer.from(Empty.encode(response).finish());
+}
+async function handleWikiGetWikiPageSettingsProtobuf(ctx, service, data, interceptors) {
+    let request;
+    let response;
+    try {
+        request = GetWikiPageSettingsRequest.decode(data);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            const msg = 'the protobuf request could not be decoded';
+            throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true);
+        }
+    }
+    if (interceptors && interceptors.length > 0) {
+        const interceptor = chainInterceptors(...interceptors);
+        response = await interceptor(ctx, request, (ctx, inputReq) => {
+            return service.GetWikiPageSettings(ctx, inputReq);
+        });
+    }
+    else {
+        response = await service.GetWikiPageSettings(ctx, request);
+    }
+    return Buffer.from(WikiPageSettings.encode(response).finish());
+}
+async function handleWikiUpdateWikiPageSettingsProtobuf(ctx, service, data, interceptors) {
+    let request;
+    let response;
+    try {
+        request = UpdateWikiPageSettingsRequest.decode(data);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            const msg = 'the protobuf request could not be decoded';
+            throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true);
+        }
+    }
+    if (interceptors && interceptors.length > 0) {
+        const interceptor = chainInterceptors(...interceptors);
+        response = await interceptor(ctx, request, (ctx, inputReq) => {
+            return service.UpdateWikiPageSettings(ctx, inputReq);
+        });
+    }
+    else {
+        response = await service.UpdateWikiPageSettings(ctx, request);
+    }
+    return Buffer.from(WikiPageSettings.encode(response).finish());
+}
+async function handleWikiAllowEditorProtobuf(ctx, service, data, interceptors) {
+    let request;
+    let response;
+    try {
+        request = AllowEditorRequest.decode(data);
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            const msg = 'the protobuf request could not be decoded';
+            throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true);
+        }
+    }
+    if (interceptors && interceptors.length > 0) {
+        const interceptor = chainInterceptors(...interceptors);
+        response = await interceptor(ctx, request, (ctx, inputReq) => {
+            return service.AllowEditor(ctx, inputReq);
+        });
+    }
+    else {
+        response = await service.AllowEditor(ctx, request);
+    }
+    return Buffer.from(Empty.encode(response).finish());
+}

package/types/devvit/plugin/redditapiv2/redditapiv2.d.ts

@@ -3,11 +3,11 @@
  *
  * @packageDocumentation
  */
-import _m0 from 'protobufjs/minimal.js';
+import _m0 from "protobufjs/minimal.js";
 import { Metadata } from "../../../../lib/Types.js";
-import { JsonStatus } from '../redditapi/common/common_msg.js';
-import { DeleteFlairTemplateRequest } from '../redditapi/flair/flair_msg.js';
-import { SubredditCollectionsRequest, SubredditCollectionsResponse } from '../redditapi/postcollections/postcollections_msg.js';
+import { JsonStatus } from "../redditapi/common/common_msg.js";
+import { DeleteFlairTemplateRequest } from "../redditapi/flair/flair_msg.js";
+import { SubredditCollectionsRequest, SubredditCollectionsResponse } from "../redditapi/postcollections/postcollections_msg.js";
 export interface RedditAPIV2 {
     GetSubredditCollections(request: SubredditCollectionsRequest, metadata?: Metadata): Promise<SubredditCollectionsResponse>;
     DeleteFlairTemplate(request: DeleteFlairTemplateRequest, metadata?: Metadata): Promise<JsonStatus>;