new website beginning

src/components/HeaderItem.tsx

@@ -0,0 +1,30 @@
+import Link from "next/link"
+
+type HeaderItemProps = {
+    content: string,
+    linkTo: string,
+    onClick?: any, // don't even wanna bother
+    newWindow?: boolean
+}
+export default function HeaderItem(props: HeaderItemProps) {
+    console.log(props, props.newWindow ? "_blank" : "self")
+    if (props.onClick) {
+        return (
+            <>
+                <button className="inline hover:text-gray-500 hover:underline pr-2 "
+                    onClick={props.onClick}
+                >
+                    {props.content}
+                </button>
+            </>
+        )
+    } else {
+        return (
+            <p className="inline pr-2 hover:text-gray-500 hover:underline">
+                <Link href={props.linkTo} target={props.newWindow ? "_blank" : "_self"}>
+                    {props.content}
+                </Link>
+            </p>
+        )
+    }
+}

src/components/ReviewCard.tsx

@@ -0,0 +1,18 @@
+import Image from "next/image"
+
+type ReviewCardProps = {
+    title: string,
+    image: string,
+    url: string
+}
+
+export default function ReviewCard(props: ReviewCardProps) {
+    return (
+        <>
+            <div className="inline pr-4 pb-2">
+                <Image alt={props.title + " cover"} width="160" height="160" src={props.image} />
+                <p className="font-bold pt-2 text-center">{props.title}</p>
+            </div>
+        </>
+    )
+}

src/components/header.tsx

@@ -0,0 +1,22 @@
+import Link from "next/link";
+import {useSession, signIn, signOut} from 'next-auth/react';
+import HeaderItem from "./HeaderItem";
+
+export default function Header() {
+    const { data: session, status } = useSession()
+
+    return (
+        <>
+            <div className="text-white w-52 pt-2 pb-4 mx-auto">
+                <p className="text-2xl font-bold">alex</p>
+                <div className="inline-block pb-2">
+                    <HeaderItem content="home" linkTo="/" />
+                    <HeaderItem content="reviews" linkTo="/reviews" />
+                    <HeaderItem content="contact" linkTo="/contact" />
+                    <HeaderItem content={status == "unauthenticated" ? "login" : "logout" } onClick={status == "authenticated" ? signOut : signIn} linkTo="" />
+                </div>
+                <hr />
+            </div>
+        </>
+    )
+}

src/env.mjs

@@ -0,0 +1,67 @@
+import { createEnv } from "@t3-oss/env-nextjs";
+import { z } from "zod";
+
+export const env = createEnv({
+  /**
+   * Specify your server-side environment variables schema here. This way you can ensure the app
+   * isn't built with invalid env vars.
+   */
+  server: {
+    DATABASE_URL: z
+      .string()
+      .url()
+      .refine(
+        (str) => !str.includes("YOUR_MYSQL_URL_HERE"),
+        "You forgot to change the default URL"
+      ),
+    NODE_ENV: z
+      .enum(["development", "test", "production"])
+      .default("development"),
+    NEXTAUTH_SECRET:
+      process.env.NODE_ENV === "production"
+        ? z.string()
+        : z.string().optional(),
+    NEXTAUTH_URL: z.preprocess(
+      // This makes Vercel deployments not fail if you don't set NEXTAUTH_URL
+      // Since NextAuth.js automatically uses the VERCEL_URL if present.
+      (str) => process.env.VERCEL_URL ?? str,
+      // VERCEL_URL doesn't include `https` so it cant be validated as a URL
+      process.env.VERCEL ? z.string() : z.string().url()
+    ),
+    // Add ` on ID and SECRET if you want to make sure they're not empty
+    DISCORD_CLIENT_ID: z.string(),
+    DISCORD_CLIENT_SECRET: z.string(),
+  },
+
+  /**
+   * Specify your client-side environment variables schema here. This way you can ensure the app
+   * isn't built with invalid env vars. To expose them to the client, prefix them with
+   * `NEXT_PUBLIC_`.
+   */
+  client: {
+    // NEXT_PUBLIC_CLIENTVAR: z.string(),
+  },
+
+  /**
+   * You can't destruct `process.env` as a regular object in the Next.js edge runtimes (e.g.
+   * middlewares) or client-side so we need to destruct manually.
+   */
+  runtimeEnv: {
+    DATABASE_URL: process.env.DATABASE_URL,
+    NODE_ENV: process.env.NODE_ENV,
+    NEXTAUTH_SECRET: process.env.NEXTAUTH_SECRET,
+    NEXTAUTH_URL: process.env.NEXTAUTH_URL,
+    DISCORD_CLIENT_ID: process.env.DISCORD_CLIENT_ID,
+    DISCORD_CLIENT_SECRET: process.env.DISCORD_CLIENT_SECRET,
+  },
+  /**
+   * Run `build` or `dev` with `SKIP_ENV_VALIDATION` to skip env validation. This is especially
+   * useful for Docker builds.
+   */
+  skipValidation: !!process.env.SKIP_ENV_VALIDATION,
+  /**
+   * Makes it so that empty strings are treated as undefined.
+   * `SOME_VAR: z.string()` and `SOME_VAR=''` will throw an error.
+   */
+  emptyStringAsUndefined: true,
+});

src/pages/_app.tsx

@@ -0,0 +1,20 @@
+import { type Session } from "next-auth";
+import { SessionProvider } from "next-auth/react";
+import { type AppType } from "next/app";
+
+import { api } from "@/utils/api";
+
+import "@/styles/globals.css";
+
+const MyApp: AppType<{ session: Session | null }> = ({
+  Component,
+  pageProps: { session, ...pageProps },
+}) => {
+  return (
+    <SessionProvider session={session}>
+      <Component {...pageProps} />
+    </SessionProvider>
+  );
+};
+
+export default api.withTRPC(MyApp);

src/pages/api/auth/[...nextauth].ts

@@ -0,0 +1,5 @@
+import NextAuth from "next-auth";
+
+import { authOptions } from "@/server/auth";
+
+export default NextAuth(authOptions);

src/pages/api/trpc/[trpc].ts

@@ -0,0 +1,19 @@
+import { createNextApiHandler } from "@trpc/server/adapters/next";
+
+import { env } from "@/env.mjs";
+import { appRouter } from "@/server/api/root";
+import { createTRPCContext } from "@/server/api/trpc";
+
+// export API handler
+export default createNextApiHandler({
+  router: appRouter,
+  createContext: createTRPCContext,
+  onError:
+    env.NODE_ENV === "development"
+      ? ({ path, error }) => {
+          console.error(
+            `❌ tRPC failed on ${path ?? "<no-path>"}: ${error.message}`
+          );
+        }
+      : undefined,
+});

src/pages/example.tsx

@@ -0,0 +1,80 @@
+import { signIn, signOut, useSession } from "next-auth/react";
+import Head from "next/head";
+import Link from "next/link";
+
+import { api } from "@/utils/api";
+
+export default function Home() {
+  const hello = api.post.hello.useQuery({ text: "from tRPC" });
+
+  return (
+    <>
+      <Head>
+        <title>Create T3 App</title>
+        <meta name="description" content="Generated by create-t3-app" />
+        <link rel="icon" href="/favicon.ico" />
+      </Head>
+      <main className=" flex min-h-screen flex-col items-center justify-center bg-gradient-to-b from-[#2e026d] to-[#15162c]">
+        <div className="container flex flex-col items-center justify-center gap-12 px-4 py-16 ">
+          <h1 className="text-5xl font-extrabold tracking-tight text-white sm:text-[5rem]">
+            Create <span className="text-[hsl(280,100%,70%)]">T3</span> App
+          </h1>
+          <div className="grid grid-cols-1 gap-4 sm:grid-cols-2 md:gap-8">
+            <Link
+              className="flex max-w-xs flex-col gap-4 rounded-xl bg-white/10 p-4 text-white hover:bg-white/20"
+              href="https://create.t3.gg/en/usage/first-steps"
+              target="_blank"
+            >
+              <h3 className="text-2xl font-bold">First Steps →</h3>
+              <div className="text-lg">
+                Just the basics - Everything you need to know to set up your
+                database and authentication.
+              </div>
+            </Link>
+            <Link
+              className="flex max-w-xs flex-col gap-4 rounded-xl bg-white/10 p-4 text-white hover:bg-white/20"
+              href="https://create.t3.gg/en/introduction"
+              target="_blank"
+            >
+              <h3 className="text-2xl font-bold">Documentation →</h3>
+              <div className="text-lg">
+                Learn more about Create T3 App, the libraries it uses, and how
+                to deploy it.
+              </div>
+            </Link>
+          </div>
+          <div className="flex flex-col items-center gap-2">
+            <p className="text-2xl text-white">
+              {hello.data ? hello.data.greeting : "Loading tRPC query..."}
+            </p>
+            <AuthShowcase />
+          </div>
+        </div>
+      </main>
+    </>
+  );
+}
+
+function AuthShowcase() {
+  const { data: sessionData } = useSession();
+
+  const { data: secretMessage } = api.post.getSecretMessage.useQuery(
+    undefined, // no input
+    { enabled: sessionData?.user !== undefined }
+  );
+
+  return (
+    <div className="flex flex-col items-center justify-center gap-4">
+      <p className="text-center text-2xl text-white">
+        {sessionData && <span>Logged in as {sessionData.user?.name}</span>}
+        {secretMessage && <span> - {secretMessage}</span>}
+      </p>
+      <button
+        className="rounded-full bg-white/10 px-10 py-3 font-semibold text-white no-underline transition hover:bg-white/20"
+        onClick={sessionData ? () => void signOut() : () => void signIn()}
+      >
+        {sessionData ? "Sign out" : "Sign in"}
+      </button>
+    </div>
+  );
+}

src/pages/index.tsx

@@ -0,0 +1,14 @@
+import { signIn, signOut, useSession } from "next-auth/react";
+import Head from "next/head"
+import Header from "@/components/header";
+
+export default function Home() {
+    return (
+        <main className="min-h-screen bg-black color-white">
+            <div className="w-1/2 mx-auto text-white">
+                <Header />
+                <p>test</p>
+            </div>
+        </main>
+    )
+} 

src/pages/reviews/[name].tsx

@@ -0,0 +1,17 @@
+import {useRouter} from 'next/router';
+import {useState, useEffect} from 'react'
+import {api} from '@/utils/api'
+import { useSession } from 'next-auth/react';
+
+export default function ReviewPage() {
+    const router = useRouter()
+    const name = router.query.name as string
+    const {data: bookData} = api.post.getOne.useQuery(name)
+    const [view,setView] = useState(null)
+
+    return (
+        <>
+            <p>Post: {router.query.name}</p>
+        </>
+    )
+}

src/pages/reviews/create.tsx

@@ -0,0 +1,68 @@
+import {useSession, getSession} from 'next-auth/react';
+import {useState, useEffect, FormEvent} from 'react';
+import Header from '@/components/header';
+import Router from 'next/router';
+import { api } from "@/utils/api";
+
+export default function Page() {
+    const { data: session, status } = useSession()
+    const mutation = api.post.create.useMutation()
+    const [loading, setLoading] = useState(true)
+
+    useEffect(() => {
+        if (status == "unauthenticated") {
+            console.log('user is unauthenticated!')
+            Router.replace('/')
+        } else {
+            setLoading(false)
+        }
+    }, [status])
+
+    function onSubmit(event: FormEvent<HTMLFormElement>) {
+        event.preventDefault()
+
+        const object = {
+            name: event.target.title.value,
+            reviewContents: event.target.review.value,
+            image: event.target.image.value,
+            type: event.target.type.value
+        }
+
+        mutation.mutate(object)
+    }
+
+    if (!loading) {
+        return (
+            <main className="min-h-screen bg-black color-white">
+                <div className="w-1/2 mx-auto text-white">
+                    <Header />
+                    <form onSubmit={onSubmit} className="text-black">
+                        <div className="bg-gray-500 text-center">
+                            <label className="font-bold">Title</label><br />
+                            <input name="title" type="text" /><br />
+
+                            <label className="font-bold">Image URL</label><br />
+                            <input name="image" type="text" /><br />
+                            
+                            <label className="font-bold">Content Type (book, movie, tv, game)</label><br />
+                            <input name="type" type="text" /><br />
+
+                            <label className="font-bold">Review</label><br />
+                            <textarea name="review" />
+
+                            <button type="submit">submit</button>
+                        </div>
+                    </form>
+                </div>
+            </main>
+        )
+    } else {
+        return (
+            <main>
+                <p>
+                    Loading..
+                </p>
+            </main>
+        )
+    }
+}

src/pages/reviews/index.tsx

@@ -0,0 +1,47 @@
+import Header from "@/components/header"
+import ReviewCard from "@/components/ReviewCard"
+import {useSession} from 'next-auth/react';
+import {useState, useEffect} from 'react';
+import { api } from "@/utils/api";
+
+type GenericItemType = {
+    name: string,
+    image: string
+}
+
+export default function Reviews() {
+    const { data: sessionData, status } = useSession();
+    const {data: itemData} = api.post.getAll.useQuery()
+    const [list, setList] = useState<null | JSX.Element[]>(null)
+
+    useEffect(() => {
+        if (itemData) {
+            setList(
+                itemData?.map((v: GenericItemType) => {
+                    return <ReviewCard title={v.name} url={`/reviews/${v.name}`} image={v.image} />
+                })
+            )
+        }
+    }, [itemData])
+
+    return (
+        <main className="min-h-screen bg-black color-white">
+            <div className="w-1/2 mx-auto text-white">
+                <Header />
+                {
+                    status == "authenticated" ?
+                    <p className="text-center font-bold">
+                        <a href="/reviews/create">
+                            Create
+                        </a>
+                    </p>
+                    :
+                    ""
+                }  
+                <div className="flex flex-wrap justify-center">
+                    {list}
+                </div>
+            </div>
+        </main>
+    )
+}

src/server/api/root.ts

@@ -0,0 +1,14 @@
+import { postRouter } from "@/server/api/routers/post";
+import { createTRPCRouter } from "@/server/api/trpc";
+
+/**
+ * This is the primary router for your server.
+ *
+ * All routers added in /api/routers should be manually added here.
+ */
+export const appRouter = createTRPCRouter({
+  post: postRouter,
+});
+
+// export type definition of API
+export type AppRouter = typeof appRouter;

src/server/api/routers/post.ts

@@ -0,0 +1,54 @@
+import { z } from "zod";
+
+import {
+  createTRPCRouter,
+  protectedProcedure,
+  publicProcedure,
+} from "@/server/api/trpc";
+
+export const postRouter = createTRPCRouter({
+  create: protectedProcedure
+    .input(
+      z.object({
+        name: z.string().min(1),
+        reviewContents: z.string().min(1),
+        type: z.string().min(1),
+        image: z.string().min(1)
+      })
+    )
+    .mutation(async ({ ctx, input }) => {
+      // simulate a slow db call
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+
+      return ctx.db.post.create({
+        data: {
+          name: input.name,
+          reviewContents: input.reviewContents,
+          type: input.type,
+          image: input.image,
+          createdBy: { connect: { id: ctx.session.user.id } },
+        },
+      });
+    }),
+
+  getOne: publicProcedure
+  .input(String)
+  .query(({ ctx, input }) => {
+    return ctx.db.post.findFirst({
+      where: { name: input },
+    });
+  }),
+
+  getAll: publicProcedure
+  .query(({ctx}) => {
+    return ctx.db.post.findMany()
+  }),
+
+  getAllOfType: publicProcedure
+  .input(String)
+  .query(({ctx, input}) => {
+    return ctx.db.post.findMany({
+      where: { type: input }
+    })
+  })
+});

src/server/api/trpc.ts

@@ -0,0 +1,131 @@
+/**
+ * YOU PROBABLY DON'T NEED TO EDIT THIS FILE, UNLESS:
+ * 1. You want to modify request context (see Part 1).
+ * 2. You want to create a new middleware or type of procedure (see Part 3).
+ *
+ * TL;DR - This is where all the tRPC server stuff is created and plugged in. The pieces you will
+ * need to use are documented accordingly near the end.
+ */
+
+import { initTRPC, TRPCError } from "@trpc/server";
+import { type CreateNextContextOptions } from "@trpc/server/adapters/next";
+import { type Session } from "next-auth";
+import superjson from "superjson";
+import { ZodError } from "zod";
+
+import { getServerAuthSession } from "@/server/auth";
+import { db } from "@/server/db";
+
+/**
+ * 1. CONTEXT
+ *
+ * This section defines the "contexts" that are available in the backend API.
+ *
+ * These allow you to access things when processing a request, like the database, the session, etc.
+ */
+
+interface CreateContextOptions {
+  session: Session | null;
+}
+
+/**
+ * This helper generates the "internals" for a tRPC context. If you need to use it, you can export
+ * it from here.
+ *
+ * Examples of things you may need it for:
+ * - testing, so we don't have to mock Next.js' req/res
+ * - tRPC's `createSSGHelpers`, where we don't have req/res
+ *
+ * @see https://create.t3.gg/en/usage/trpc#-serverapitrpcts
+ */
+const createInnerTRPCContext = (opts: CreateContextOptions) => {
+  return {
+    session: opts.session,
+    db,
+  };
+};
+
+/**
+ * This is the actual context you will use in your router. It will be used to process every request
+ * that goes through your tRPC endpoint.
+ *
+ * @see https://trpc.io/docs/context
+ */
+export const createTRPCContext = async (opts: CreateNextContextOptions) => {
+  const { req, res } = opts;
+
+  // Get the session from the server using the getServerSession wrapper function
+  const session = await getServerAuthSession({ req, res });
+
+  return createInnerTRPCContext({
+    session,
+  });
+};
+
+/**
+ * 2. INITIALIZATION
+ *
+ * This is where the tRPC API is initialized, connecting the context and transformer. We also parse
+ * ZodErrors so that you get typesafety on the frontend if your procedure fails due to validation
+ * errors on the backend.
+ */
+
+const t = initTRPC.context<typeof createTRPCContext>().create({
+  transformer: superjson,
+  errorFormatter({ shape, error }) {
+    return {
+      ...shape,
+      data: {
+        ...shape.data,
+        zodError:
+          error.cause instanceof ZodError ? error.cause.flatten() : null,
+      },
+    };
+  },
+});
+
+/**
+ * 3. ROUTER & PROCEDURE (THE IMPORTANT BIT)
+ *
+ * These are the pieces you use to build your tRPC API. You should import these a lot in the
+ * "/src/server/api/routers" directory.
+ */
+
+/**
+ * This is how you create new routers and sub-routers in your tRPC API.
+ *
+ * @see https://trpc.io/docs/router
+ */
+export const createTRPCRouter = t.router;
+
+/**
+ * Public (unauthenticated) procedure
+ *
+ * This is the base piece you use to build new queries and mutations on your tRPC API. It does not
+ * guarantee that a user querying is authorized, but you can still access user session data if they
+ * are logged in.
+ */
+export const publicProcedure = t.procedure;
+
+/** Reusable middleware that enforces users are logged in before running the procedure. */
+const enforceUserIsAuthed = t.middleware(({ ctx, next }) => {
+  if (!ctx.session?.user) {
+    throw new TRPCError({ code: "UNAUTHORIZED" });
+  }
+  return next({
+    ctx: {
+      // infers the `session` as non-nullable
+      session: { ...ctx.session, user: ctx.session.user },
+    },
+  });
+});
+
+/**
+ * Protected (authenticated) procedure
+ *
+ * If you want a query or mutation to ONLY be accessible to logged in users, use this. It verifies
+ * the session is valid and guarantees `ctx.session.user` is not null.
+ *
+ * @see https://trpc.io/docs/procedures
+ */
+export const protectedProcedure = t.procedure.use(enforceUserIsAuthed);

src/server/auth.ts

@@ -0,0 +1,77 @@
+import { PrismaAdapter } from "@next-auth/prisma-adapter";
+import { type GetServerSidePropsContext } from "next";
+import {
+  getServerSession,
+  type DefaultSession,
+  type NextAuthOptions,
+} from "next-auth";
+import DiscordProvider from "next-auth/providers/discord";
+
+import { env } from "@/env.mjs";
+import { db } from "@/server/db";
+
+/**
+ * Module augmentation for `next-auth` types. Allows us to add custom properties to the `session`
+ * object and keep type safety.
+ *
+ * @see https://next-auth.js.org/getting-started/typescript#module-augmentation
+ */
+declare module "next-auth" {
+  interface Session extends DefaultSession {
+    user: DefaultSession["user"] & {
+      id: string;
+      // ...other properties
+      // role: UserRole;
+    };
+  }
+
+  // interface User {
+  //   // ...other properties
+  //   // role: UserRole;
+  // }
+}
+
+/**
+ * Options for NextAuth.js used to configure adapters, providers, callbacks, etc.
+ *
+ * @see https://next-auth.js.org/configuration/options
+ */
+export const authOptions: NextAuthOptions = {
+  callbacks: {
+    session: ({ session, user }) => ({
+      ...session,
+      user: {
+        ...session.user,
+        id: user.id,
+      },
+    }),
+  },
+  adapter: PrismaAdapter(db),
+  providers: [
+    DiscordProvider({
+      clientId: env.DISCORD_CLIENT_ID,
+      clientSecret: env.DISCORD_CLIENT_SECRET,
+    }),
+    /**
+     * ...add more providers here.
+     *
+     * Most other providers require a bit more work than the Discord provider. For example, the
+     * GitHub provider requires you to add the `refresh_token_expires_in` field to the Account
+     * model. Refer to the NextAuth.js docs for the provider you want to use. Example:
+     *
+     * @see https://next-auth.js.org/providers/github
+     */
+  ],
+};
+
+/**
+ * Wrapper for `getServerSession` so that you don't need to import the `authOptions` in every file.
+ *
+ * @see https://next-auth.js.org/configuration/nextjs
+ */
+export const getServerAuthSession = (ctx: {
+  req: GetServerSidePropsContext["req"];
+  res: GetServerSidePropsContext["res"];
+}) => {
+  return getServerSession(ctx.req, ctx.res, authOptions);
+};

src/server/db.ts

@@ -0,0 +1,16 @@
+import { PrismaClient } from "@prisma/client";
+
+import { env } from "@/env.mjs";
+
+const globalForPrisma = globalThis as unknown as {
+  prisma: PrismaClient | undefined;
+};
+
+export const db =
+  globalForPrisma.prisma ??
+  new PrismaClient({
+    log:
+      env.NODE_ENV === "development" ? ["query", "error", "warn"] : ["error"],
+  });
+
+if (env.NODE_ENV !== "production") globalForPrisma.prisma = db;

src/styles/globals.css

@@ -0,0 +1,3 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;

src/utils/api.ts

@@ -0,0 +1,68 @@
+/**
+ * This is the client-side entrypoint for your tRPC API. It is used to create the `api` object which
+ * contains the Next.js App-wrapper, as well as your type-safe React Query hooks.
+ *
+ * We also create a few inference helpers for input and output types.
+ */
+import { httpBatchLink, loggerLink } from "@trpc/client";
+import { createTRPCNext } from "@trpc/next";
+import { type inferRouterInputs, type inferRouterOutputs } from "@trpc/server";
+import superjson from "superjson";
+
+import { type AppRouter } from "@/server/api/root";
+
+const getBaseUrl = () => {
+  if (typeof window !== "undefined") return ""; // browser should use relative url
+  if (process.env.VERCEL_URL) return `https://${process.env.VERCEL_URL}`; // SSR should use vercel url
+  return `http://localhost:${process.env.PORT ?? 3000}`; // dev SSR should use localhost
+};
+
+/** A set of type-safe react-query hooks for your tRPC API. */
+export const api = createTRPCNext<AppRouter>({
+  config() {
+    return {
+      /**
+       * Transformer used for data de-serialization from the server.
+       *
+       * @see https://trpc.io/docs/data-transformers
+       */
+      transformer: superjson,
+
+      /**
+       * Links used to determine request flow from client to server.
+       *
+       * @see https://trpc.io/docs/links
+       */
+      links: [
+        loggerLink({
+          enabled: (opts) =>
+            process.env.NODE_ENV === "development" ||
+            (opts.direction === "down" && opts.result instanceof Error),
+        }),
+        httpBatchLink({
+          url: `${getBaseUrl()}/api/trpc`,
+        }),
+      ],
+    };
+  },
+  /**
+   * Whether tRPC should await queries when server rendering pages.
+   *
+   * @see https://trpc.io/docs/nextjs#ssr-boolean-default-false
+   */
+  ssr: false,
+});
+
+/**
+ * Inference helper for inputs.
+ *
+ * @example type HelloInput = RouterInputs['example']['hello']
+ */
+export type RouterInputs = inferRouterInputs<AppRouter>;
+
+/**
+ * Inference helper for outputs.
+ *
+ * @example type HelloOutput = RouterOutputs['example']['hello']
+ */
+export type RouterOutputs = inferRouterOutputs<AppRouter>;