@arken/seer-protocol 0.1.4 → 0.1.5

package/build/video/video.router.d.ts

@@ -0,0 +1,563 @@
+import { z as zod } from 'zod';
+import { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
+import type { RouterContext } from '../types';
+export declare const z: typeof zod;
+export declare const t: {
+    _config: import("@trpc/server/dist/unstable-core-do-not-import").RootConfig<{
+        ctx: RouterContext;
+        meta: object;
+        errorShape: import("@trpc/server/dist/unstable-core-do-not-import").DefaultErrorShape;
+        transformer: false;
+    }>;
+    procedure: import("@trpc/server/dist/unstable-core-do-not-import").ProcedureBuilder<RouterContext, object, object, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, false>;
+    middleware: <$ContextOverrides>(fn: import("@trpc/server/dist/unstable-core-do-not-import").MiddlewareFunction<RouterContext, object, object, $ContextOverrides, unknown>) => import("@trpc/server/dist/unstable-core-do-not-import").MiddlewareBuilder<RouterContext, object, $ContextOverrides, unknown>;
+    router: {
+        <TInput extends import("@trpc/server").RouterRecord>(input: TInput): import("@trpc/server/dist/unstable-core-do-not-import").BuiltRouter<{
+            ctx: RouterContext;
+            meta: object;
+            errorShape: import("@trpc/server/dist/unstable-core-do-not-import").DefaultErrorShape;
+            transformer: false;
+        }, TInput>;
+        <TInput extends import("@trpc/server/dist/unstable-core-do-not-import").CreateRouterOptions>(input: TInput): import("@trpc/server/dist/unstable-core-do-not-import").BuiltRouter<{
+            ctx: RouterContext;
+            meta: object;
+            errorShape: import("@trpc/server/dist/unstable-core-do-not-import").DefaultErrorShape;
+            transformer: false;
+        }, import("@trpc/server/dist/unstable-core-do-not-import").DecorateCreateRouterOptions<TInput>>;
+    };
+    mergeRouters: typeof import("@trpc/server/dist/unstable-core-do-not-import").mergeRouters;
+    createCallerFactory: <TRecord extends import("@trpc/server").RouterRecord>(router: Pick<import("@trpc/server/dist/unstable-core-do-not-import").Router<{
+        ctx: RouterContext;
+        meta: object;
+        errorShape: import("@trpc/server/dist/unstable-core-do-not-import").DefaultErrorShape;
+        transformer: false;
+    }, TRecord>, "_def">) => import("@trpc/server/dist/unstable-core-do-not-import").RouterCaller<{
+        ctx: RouterContext;
+        meta: object;
+        errorShape: import("@trpc/server/dist/unstable-core-do-not-import").DefaultErrorShape;
+        transformer: false;
+    }, TRecord>;
+};
+export declare const router: {
+    <TInput extends import("@trpc/server").RouterRecord>(input: TInput): import("@trpc/server/dist/unstable-core-do-not-import").BuiltRouter<{
+        ctx: RouterContext;
+        meta: object;
+        errorShape: import("@trpc/server/dist/unstable-core-do-not-import").DefaultErrorShape;
+        transformer: false;
+    }, TInput>;
+    <TInput extends import("@trpc/server/dist/unstable-core-do-not-import").CreateRouterOptions>(input: TInput): import("@trpc/server/dist/unstable-core-do-not-import").BuiltRouter<{
+        ctx: RouterContext;
+        meta: object;
+        errorShape: import("@trpc/server/dist/unstable-core-do-not-import").DefaultErrorShape;
+        transformer: false;
+    }, import("@trpc/server/dist/unstable-core-do-not-import").DecorateCreateRouterOptions<TInput>>;
+};
+export declare const procedure: import("@trpc/server/dist/unstable-core-do-not-import").ProcedureBuilder<RouterContext, object, object, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/dist/unstable-core-do-not-import").unsetMarker, false>;
+export declare const createRouter: () => import("@trpc/server/dist/unstable-core-do-not-import").BuiltRouter<{
+    ctx: RouterContext;
+    meta: object;
+    errorShape: import("@trpc/server/dist/unstable-core-do-not-import").DefaultErrorShape;
+    transformer: false;
+}, {
+    getVideo: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            query?: {
+                cursor?: Record<string, any>;
+                select?: Record<string, boolean>;
+                skip?: number;
+                where?: any;
+                take?: number;
+                orderBy?: Record<string, "asc" | "desc">;
+                include?: Record<string, boolean>;
+            };
+        };
+        output: any;
+    }>;
+    createVideo: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            data?: {
+                name?: string;
+                key?: string;
+                data?: any;
+                description?: string;
+                applicationId?: string | import("mongoose").Types.ObjectId;
+                createdDate?: Date;
+                updatedDate?: Date;
+                status?: "Active" | "Paused" | "Pending" | "Archived";
+                ownerId?: string | import("mongoose").Types.ObjectId;
+                meta?: any;
+                merkleLeaf?: string;
+                merkleIndex?: number;
+                createdById?: string | import("mongoose").Types.ObjectId;
+                editedById?: string | import("mongoose").Types.ObjectId;
+                deletedById?: string | import("mongoose").Types.ObjectId;
+                deletedDate?: Date;
+                title?: string;
+                url?: string;
+                duration?: number;
+                youtubeId?: string;
+            };
+        };
+        output: any;
+    }>;
+    updateVideo: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            data?: {
+                name?: string;
+                key?: string;
+                id?: string | import("mongoose").Types.ObjectId;
+                data?: any;
+                description?: string;
+                applicationId?: string | import("mongoose").Types.ObjectId;
+                createdDate?: Date;
+                updatedDate?: Date;
+                status?: "Active" | "Paused" | "Pending" | "Archived";
+                ownerId?: string | import("mongoose").Types.ObjectId;
+                meta?: any;
+                merkleLeaf?: string;
+                merkleIndex?: number;
+                createdById?: string | import("mongoose").Types.ObjectId;
+                editedById?: string | import("mongoose").Types.ObjectId;
+                deletedById?: string | import("mongoose").Types.ObjectId;
+                deletedDate?: Date;
+                title?: string;
+                url?: string;
+                duration?: number;
+                youtubeId?: string;
+            };
+            query?: {
+                cursor?: Record<string, any>;
+                select?: Record<string, boolean>;
+                skip?: number;
+                where?: any;
+                take?: number;
+                orderBy?: Record<string, "asc" | "desc">;
+                include?: Record<string, boolean>;
+            };
+        };
+        output: any;
+    }>;
+    deleteVideo: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            query?: {
+                cursor?: Record<string, any>;
+                select?: Record<string, boolean>;
+                skip?: number;
+                where?: any;
+                take?: number;
+                orderBy?: Record<string, "asc" | "desc">;
+                include?: Record<string, boolean>;
+            };
+        };
+        output: any;
+    }>;
+    getVideoParticipant: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            query?: {
+                cursor?: Record<string, any>;
+                select?: Record<string, boolean>;
+                skip?: number;
+                where?: any;
+                take?: number;
+                orderBy?: Record<string, "asc" | "desc">;
+                include?: Record<string, boolean>;
+            };
+        };
+        output: any;
+    }>;
+    createVideoParticipant: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            data?: {
+                name?: string;
+                key?: string;
+                data?: any;
+                description?: string;
+                applicationId?: string | import("mongoose").Types.ObjectId;
+                createdDate?: Date;
+                updatedDate?: Date;
+                status?: "Active" | "Paused" | "Pending" | "Archived";
+                ownerId?: string | import("mongoose").Types.ObjectId;
+                meta?: any;
+                merkleLeaf?: string;
+                merkleIndex?: number;
+                createdById?: string | import("mongoose").Types.ObjectId;
+                editedById?: string | import("mongoose").Types.ObjectId;
+                deletedById?: string | import("mongoose").Types.ObjectId;
+                deletedDate?: Date;
+                profileId?: string | import("mongoose").Types.ObjectId;
+                role?: "Host" | "Contributor" | "Guest";
+                videoId?: string | import("mongoose").Types.ObjectId;
+            };
+        };
+        output: any;
+    }>;
+    updateVideoParticipant: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            data?: {
+                name?: string;
+                key?: string;
+                id?: string | import("mongoose").Types.ObjectId;
+                data?: any;
+                description?: string;
+                applicationId?: string | import("mongoose").Types.ObjectId;
+                createdDate?: Date;
+                updatedDate?: Date;
+                status?: "Active" | "Paused" | "Pending" | "Archived";
+                ownerId?: string | import("mongoose").Types.ObjectId;
+                meta?: any;
+                merkleLeaf?: string;
+                merkleIndex?: number;
+                createdById?: string | import("mongoose").Types.ObjectId;
+                editedById?: string | import("mongoose").Types.ObjectId;
+                deletedById?: string | import("mongoose").Types.ObjectId;
+                deletedDate?: Date;
+                profileId?: string | import("mongoose").Types.ObjectId;
+                role?: "Host" | "Contributor" | "Guest";
+                videoId?: string | import("mongoose").Types.ObjectId;
+            };
+            query?: {
+                cursor?: Record<string, any>;
+                select?: Record<string, boolean>;
+                skip?: number;
+                where?: any;
+                take?: number;
+                orderBy?: Record<string, "asc" | "desc">;
+                include?: Record<string, boolean>;
+            };
+        };
+        output: any;
+    }>;
+    deleteVideoParticipant: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            query?: {
+                cursor?: Record<string, any>;
+                select?: Record<string, boolean>;
+                skip?: number;
+                where?: any;
+                take?: number;
+                orderBy?: Record<string, "asc" | "desc">;
+                include?: Record<string, boolean>;
+            };
+        };
+        output: any;
+    }>;
+    getVideoDialogue: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            query?: {
+                cursor?: Record<string, any>;
+                select?: Record<string, boolean>;
+                skip?: number;
+                where?: any;
+                take?: number;
+                orderBy?: Record<string, "asc" | "desc">;
+                include?: Record<string, boolean>;
+            };
+        };
+        output: any;
+    }>;
+    createVideoDialogue: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            data?: {
+                name?: string;
+                key?: string;
+                data?: any;
+                description?: string;
+                text?: string;
+                applicationId?: string | import("mongoose").Types.ObjectId;
+                createdDate?: Date;
+                updatedDate?: Date;
+                status?: "Active" | "Paused" | "Pending" | "Archived";
+                ownerId?: string | import("mongoose").Types.ObjectId;
+                meta?: any;
+                merkleLeaf?: string;
+                merkleIndex?: number;
+                createdById?: string | import("mongoose").Types.ObjectId;
+                editedById?: string | import("mongoose").Types.ObjectId;
+                deletedById?: string | import("mongoose").Types.ObjectId;
+                deletedDate?: Date;
+                timestamp?: string;
+                videoId?: string | import("mongoose").Types.ObjectId;
+                participantId?: string | import("mongoose").Types.ObjectId;
+            };
+        };
+        output: any;
+    }>;
+    updateVideoDialogue: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            data?: {
+                name?: string;
+                key?: string;
+                id?: string | import("mongoose").Types.ObjectId;
+                data?: any;
+                description?: string;
+                text?: string;
+                applicationId?: string | import("mongoose").Types.ObjectId;
+                createdDate?: Date;
+                updatedDate?: Date;
+                status?: "Active" | "Paused" | "Pending" | "Archived";
+                ownerId?: string | import("mongoose").Types.ObjectId;
+                meta?: any;
+                merkleLeaf?: string;
+                merkleIndex?: number;
+                createdById?: string | import("mongoose").Types.ObjectId;
+                editedById?: string | import("mongoose").Types.ObjectId;
+                deletedById?: string | import("mongoose").Types.ObjectId;
+                deletedDate?: Date;
+                timestamp?: string;
+                videoId?: string | import("mongoose").Types.ObjectId;
+                participantId?: string | import("mongoose").Types.ObjectId;
+            };
+            query?: {
+                cursor?: Record<string, any>;
+                select?: Record<string, boolean>;
+                skip?: number;
+                where?: any;
+                take?: number;
+                orderBy?: Record<string, "asc" | "desc">;
+                include?: Record<string, boolean>;
+            };
+        };
+        output: any;
+    }>;
+    deleteVideoDialogue: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            query?: {
+                cursor?: Record<string, any>;
+                select?: Record<string, boolean>;
+                skip?: number;
+                where?: any;
+                take?: number;
+                orderBy?: Record<string, "asc" | "desc">;
+                include?: Record<string, boolean>;
+            };
+        };
+        output: any;
+    }>;
+    getVideoTranscript: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            query?: {
+                cursor?: Record<string, any>;
+                select?: Record<string, boolean>;
+                skip?: number;
+                where?: any;
+                take?: number;
+                orderBy?: Record<string, "asc" | "desc">;
+                include?: Record<string, boolean>;
+            };
+        };
+        output: any;
+    }>;
+    createVideoTranscript: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            data?: {
+                name?: string;
+                key?: string;
+                data?: any;
+                description?: string;
+                applicationId?: string | import("mongoose").Types.ObjectId;
+                createdDate?: Date;
+                updatedDate?: Date;
+                status?: "Active" | "Paused" | "Pending" | "Archived";
+                ownerId?: string | import("mongoose").Types.ObjectId;
+                meta?: any;
+                merkleLeaf?: string;
+                merkleIndex?: number;
+                createdById?: string | import("mongoose").Types.ObjectId;
+                editedById?: string | import("mongoose").Types.ObjectId;
+                deletedById?: string | import("mongoose").Types.ObjectId;
+                deletedDate?: Date;
+                summary?: string;
+                videoId?: string | import("mongoose").Types.ObjectId;
+                transcript?: {
+                    name?: string;
+                    key?: string;
+                    id?: string | import("mongoose").Types.ObjectId;
+                    data?: any;
+                    description?: string;
+                    text?: string;
+                    applicationId?: string | import("mongoose").Types.ObjectId;
+                    createdDate?: Date;
+                    updatedDate?: Date;
+                    status?: "Active" | "Paused" | "Pending" | "Archived";
+                    ownerId?: string | import("mongoose").Types.ObjectId;
+                    meta?: any;
+                    merkleLeaf?: string;
+                    merkleIndex?: number;
+                    createdById?: string | import("mongoose").Types.ObjectId;
+                    editedById?: string | import("mongoose").Types.ObjectId;
+                    deletedById?: string | import("mongoose").Types.ObjectId;
+                    deletedDate?: Date;
+                    timestamp?: string;
+                    videoId?: string | import("mongoose").Types.ObjectId;
+                    participantId?: string | import("mongoose").Types.ObjectId;
+                }[];
+            };
+        };
+        output: any;
+    }>;
+    updateVideoTranscript: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            data?: {
+                name?: string;
+                key?: string;
+                id?: string | import("mongoose").Types.ObjectId;
+                data?: any;
+                description?: string;
+                applicationId?: string | import("mongoose").Types.ObjectId;
+                createdDate?: Date;
+                updatedDate?: Date;
+                status?: "Active" | "Paused" | "Pending" | "Archived";
+                ownerId?: string | import("mongoose").Types.ObjectId;
+                meta?: any;
+                merkleLeaf?: string;
+                merkleIndex?: number;
+                createdById?: string | import("mongoose").Types.ObjectId;
+                editedById?: string | import("mongoose").Types.ObjectId;
+                deletedById?: string | import("mongoose").Types.ObjectId;
+                deletedDate?: Date;
+                summary?: string;
+                videoId?: string | import("mongoose").Types.ObjectId;
+                transcript?: {
+                    name?: string;
+                    key?: string;
+                    id?: string | import("mongoose").Types.ObjectId;
+                    data?: any;
+                    description?: string;
+                    text?: string;
+                    applicationId?: string | import("mongoose").Types.ObjectId;
+                    createdDate?: Date;
+                    updatedDate?: Date;
+                    status?: "Active" | "Paused" | "Pending" | "Archived";
+                    ownerId?: string | import("mongoose").Types.ObjectId;
+                    meta?: any;
+                    merkleLeaf?: string;
+                    merkleIndex?: number;
+                    createdById?: string | import("mongoose").Types.ObjectId;
+                    editedById?: string | import("mongoose").Types.ObjectId;
+                    deletedById?: string | import("mongoose").Types.ObjectId;
+                    deletedDate?: Date;
+                    timestamp?: string;
+                    videoId?: string | import("mongoose").Types.ObjectId;
+                    participantId?: string | import("mongoose").Types.ObjectId;
+                }[];
+            };
+            query?: {
+                cursor?: Record<string, any>;
+                select?: Record<string, boolean>;
+                skip?: number;
+                where?: any;
+                take?: number;
+                orderBy?: Record<string, "asc" | "desc">;
+                include?: Record<string, boolean>;
+            };
+        };
+        output: any;
+    }>;
+    deleteVideoTranscript: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            query?: {
+                cursor?: Record<string, any>;
+                select?: Record<string, boolean>;
+                skip?: number;
+                where?: any;
+                take?: number;
+                orderBy?: Record<string, "asc" | "desc">;
+                include?: Record<string, boolean>;
+            };
+        };
+        output: any;
+    }>;
+    getVideoScene: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            query?: {
+                cursor?: Record<string, any>;
+                select?: Record<string, boolean>;
+                skip?: number;
+                where?: any;
+                take?: number;
+                orderBy?: Record<string, "asc" | "desc">;
+                include?: Record<string, boolean>;
+            };
+        };
+        output: any;
+    }>;
+    createVideoScene: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            data?: {
+                name?: string;
+                key?: string;
+                data?: any;
+                description?: string;
+                applicationId?: string | import("mongoose").Types.ObjectId;
+                createdDate?: Date;
+                updatedDate?: Date;
+                status?: "Active" | "Paused" | "Pending" | "Archived";
+                ownerId?: string | import("mongoose").Types.ObjectId;
+                meta?: any;
+                merkleLeaf?: string;
+                merkleIndex?: number;
+                createdById?: string | import("mongoose").Types.ObjectId;
+                editedById?: string | import("mongoose").Types.ObjectId;
+                deletedById?: string | import("mongoose").Types.ObjectId;
+                deletedDate?: Date;
+                videoId?: string | import("mongoose").Types.ObjectId;
+                startTime?: string;
+                endTime?: string;
+            };
+        };
+        output: any;
+    }>;
+    updateVideoScene: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            data?: {
+                name?: string;
+                key?: string;
+                id?: string | import("mongoose").Types.ObjectId;
+                data?: any;
+                description?: string;
+                applicationId?: string | import("mongoose").Types.ObjectId;
+                createdDate?: Date;
+                updatedDate?: Date;
+                status?: "Active" | "Paused" | "Pending" | "Archived";
+                ownerId?: string | import("mongoose").Types.ObjectId;
+                meta?: any;
+                merkleLeaf?: string;
+                merkleIndex?: number;
+                createdById?: string | import("mongoose").Types.ObjectId;
+                editedById?: string | import("mongoose").Types.ObjectId;
+                deletedById?: string | import("mongoose").Types.ObjectId;
+                deletedDate?: Date;
+                videoId?: string | import("mongoose").Types.ObjectId;
+                startTime?: string;
+                endTime?: string;
+            };
+            query?: {
+                cursor?: Record<string, any>;
+                select?: Record<string, boolean>;
+                skip?: number;
+                where?: any;
+                take?: number;
+                orderBy?: Record<string, "asc" | "desc">;
+                include?: Record<string, boolean>;
+            };
+        };
+        output: any;
+    }>;
+    deleteVideoScene: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            query?: {
+                cursor?: Record<string, any>;
+                select?: Record<string, boolean>;
+                skip?: number;
+                where?: any;
+                take?: number;
+                orderBy?: Record<string, "asc" | "desc">;
+                include?: Record<string, boolean>;
+            };
+        };
+        output: any;
+    }>;
+}>;
+export type Router = ReturnType<typeof createRouter>;
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/build/video/video.router.js

@@ -0,0 +1,112 @@
+import { z as zod } from 'zod';
+import { initTRPC } from '@trpc/server';
+import { customErrorFormatter, hasRole } from '@arken/node/rpc';
+import { Video, VideoParticipant, VideoDialogue, VideoTranscript, VideoScene } from './video.schema';
+import { Query } from '../schema';
+export const z = zod;
+export const t = initTRPC.context().create();
+export const router = t.router;
+export const procedure = t.procedure;
+export const createRouter = () => router({
+    getVideo: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(z.object({ query: Query }))
+        .query(({ input, ctx }) => ctx.app.service.Video.getVideo(input, ctx)),
+    createVideo: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(z.object({ data: Video.omit({ id: true }) }))
+        .mutation(({ input, ctx }) => ctx.app.service.Video.createVideo(input, ctx)),
+    updateVideo: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(z.object({ query: Query, data: Video.partial() }))
+        .mutation(({ input, ctx }) => ctx.app.service.Video.updateVideo(input, ctx)),
+    deleteVideo: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(z.object({ query: Query }))
+        .mutation(({ input, ctx }) => ctx.app.service.Video.deleteVideo(input, ctx)),
+    getVideoParticipant: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(z.object({ query: Query }))
+        .query(({ input, ctx }) => ctx.app.service.Video.getVideoParticipant(input, ctx)),
+    createVideoParticipant: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(z.object({ data: VideoParticipant.omit({ id: true }) }))
+        .mutation(({ input, ctx }) => ctx.app.service.Video.createVideoParticipant(input, ctx)),
+    updateVideoParticipant: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(z.object({ query: Query, data: VideoParticipant.partial() }))
+        .mutation(({ input, ctx }) => ctx.app.service.Video.updateVideoParticipant(input, ctx)),
+    deleteVideoParticipant: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(z.object({ query: Query }))
+        .mutation(({ input, ctx }) => ctx.app.service.Video.deleteVideoParticipant(input, ctx)),
+    getVideoDialogue: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(z.object({ query: Query }))
+        .query(({ input, ctx }) => ctx.app.service.Video.getVideoDialogue(input, ctx)),
+    createVideoDialogue: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(z.object({ data: VideoDialogue.omit({ id: true }) }))
+        .mutation(({ input, ctx }) => ctx.app.service.Video.createVideoDialogue(input, ctx)),
+    updateVideoDialogue: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(z.object({ query: Query, data: VideoDialogue.partial() }))
+        .mutation(({ input, ctx }) => ctx.app.service.Video.updateVideoDialogue(input, ctx)),
+    deleteVideoDialogue: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(z.object({ query: Query }))
+        .mutation(({ input, ctx }) => ctx.app.service.Video.deleteVideoDialogue(input, ctx)),
+    getVideoTranscript: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(z.object({ query: Query }))
+        .query(({ input, ctx }) => ctx.app.service.Video.getVideoTranscript(input, ctx)),
+    createVideoTranscript: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(z.object({ data: VideoTranscript.omit({ id: true }) }))
+        .mutation(({ input, ctx }) => ctx.app.service.Video.createVideoTranscript(input, ctx)),
+    updateVideoTranscript: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(z.object({ query: Query, data: VideoTranscript.partial() }))
+        .mutation(({ input, ctx }) => ctx.app.service.Video.updateVideoTranscript(input, ctx)),
+    deleteVideoTranscript: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(z.object({ query: Query }))
+        .mutation(({ input, ctx }) => ctx.app.service.Video.deleteVideoTranscript(input, ctx)),
+    getVideoScene: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(z.object({ query: Query }))
+        .query(({ input, ctx }) => ctx.app.service.Video.getVideoScene(input, ctx)),
+    createVideoScene: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(z.object({ data: VideoScene.omit({ id: true }) }))
+        .mutation(({ input, ctx }) => ctx.app.service.Video.createVideoScene(input, ctx)),
+    updateVideoScene: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(z.object({ query: Query, data: VideoScene.partial() }))
+        .mutation(({ input, ctx }) => ctx.app.service.Video.updateVideoScene(input, ctx)),
+    deleteVideoScene: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(z.object({ query: Query }))
+        .mutation(({ input, ctx }) => ctx.app.service.Video.deleteVideoScene(input, ctx)),
+});
+//# sourceMappingURL=video.router.js.map