Skip to content
tRPC

Input & Output Validators

On this page

tRPC procedures may define validation logic for their input and/or output, and validators are also used to infer the types of inputs and outputs (using the Standard Schema interface if available, or custom interfaces for supported validators if not). We have first class support for many popular validators, and you can integrate validators which we don't directly support.

Input Validators

By defining an input validator, tRPC can check that a procedure call is correct and return a validation error if not.

To set up an input validator, use the procedure.input() method:


export const 
const appRouter: BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
appRouter = 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t.
TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, { ctx: object; meta: object; errorShape: DefaultErrorShape; transformer: false; }>.router: RouterBuilder
<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>(_: {
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}) => BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
router({
  
hello: QueryProcedure<{
    input: {
        name: string;
    };
    output: {
        greeting: string;
    };
    meta: object;
    errorShape: DefaultErrorShape;
}>
hello: const publicProcedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>publicProcedure
    .
ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.input<z.ZodObject<{
    name: z.ZodString;
}, z.core.$strip>>(schema: z.ZodObject<{
    name: z.ZodString;
}, z.core.$strip>): ProcedureBuilder<object, object, object, {
    name: string;
}, {
    name: string;
}, UnsetMarker, UnsetMarker, false, DefaultErrorShape>
input(
      import zz.
function object<{
    name: z.ZodString;
}>(shape?: {
    name: z.ZodString;
} | undefined, params?: string | {
    error?: string | z.core.$ZodErrorMap<NonNullable<z.core.$ZodIssueUnrecognizedKeys | z.core.$ZodIssueInvalidType<unknown>>> | undefined;
    message?: string | undefined | undefined;
} | undefined): z.ZodObject<{
    name: z.ZodString;
}, z.core.$strip>
object({
        name: z.ZodStringname: import zz.function string(params?: string | z.core.$ZodStringParams): z.ZodString (+1 overload)string(),
      }),
    )
    .
ProcedureBuilder<object, object, object, { name: string; }, { name: string; }, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.query<{
    greeting: string;
}>(resolver: ProcedureResolver<object, object, object, {
    name: string;
}, UnsetMarker, {
    greeting: string;
}>): QueryProcedure<{
    input: {
        name: string;
    };
    output: {
        greeting: string;
    };
    meta: object;
    errorShape: DefaultErrorShape;
}>
query((
opts: ProcedureResolverOptions<object, object, object, {
    name: string;
}>
opts) => {
      const name = 
opts: ProcedureResolverOptions<object, object, object, {
    name: string;
}>
opts.
ProcedureResolverOptions<object, object, object, { name: string; }>.input: {
    name: string;
}
input.name: stringname;
            
const name: string
      return {
        greeting: stringgreeting: `Hello ${
opts: ProcedureResolverOptions<object, object, object, {
    name: string;
}>
opts.
ProcedureResolverOptions<object, object, object, { name: string; }>.input: {
    name: string;
}
input.name: stringname}`,
      };
    }),
});

Input Merging

.input() can be stacked to build more complex types, which is particularly useful when you want to utilise some common input to a collection of procedures in a middleware.

Input merging works by spreading object properties together. This means only object types can be chained — non-object types (like z.string()) cannot be merged. If two chained .input() calls define the same property, the later one takes precedence.


const 
const baseProcedure: ProcedureBuilder<object, object, {}, {
    townName: string;
}, {
    townName: string;
}, UnsetMarker, UnsetMarker, false, DefaultErrorShape>
baseProcedure = 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t.TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, { ctx: object; meta: object; errorShape: DefaultErrorShape; transformer: false; }>.procedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>procedure
  .
ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.input<z.ZodObject<{
    townName: z.ZodString;
}, z.core.$strip>>(schema: z.ZodObject<{
    townName: z.ZodString;
}, z.core.$strip>): ProcedureBuilder<object, object, object, {
    townName: string;
}, {
    townName: string;
}, UnsetMarker, UnsetMarker, false, DefaultErrorShape>
input(import zz.
function object<{
    townName: z.ZodString;
}>(shape?: {
    townName: z.ZodString;
} | undefined, params?: string | {
    error?: string | z.core.$ZodErrorMap<NonNullable<z.core.$ZodIssueUnrecognizedKeys | z.core.$ZodIssueInvalidType<unknown>>> | undefined;
    message?: string | undefined | undefined;
} | undefined): z.ZodObject<{
    townName: z.ZodString;
}, z.core.$strip>
object({ townName: z.ZodStringtownName: import zz.function string(params?: string | z.core.$ZodStringParams): z.ZodString (+1 overload)string() }))
  .
ProcedureBuilder<object, object, object, { townName: string; }, { townName: string; }, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.use<object>(fn: MiddlewareBuilder<{}, object, object, {
    townName: string;
}> | MiddlewareFunction<object, object, object, object, {
    townName: string;
}>): ProcedureBuilder<object, object, {}, {
    townName: string;
}, {
    townName: string;
}, UnsetMarker, UnsetMarker, false, DefaultErrorShape>
use((
opts: {
    ctx: {};
    type: ProcedureType;
    path: string;
    input: {
        townName: string;
    };
    getRawInput: GetRawInputFn;
    meta: object | undefined;
    signal: AbortSignal | undefined;
    batchIndex: number;
    next: {
        (): Promise<MiddlewareResult<object>>;
        <$ContextOverride>(opts: {
            ctx?: $ContextOverride | undefined;
            input?: unknown;
        }): Promise<MiddlewareResult<$ContextOverride>>;
        (opts: {
            getRawInput: GetRawInputFn;
        }): Promise<...>;
    };
}
opts) => {
    const input = 
opts: {
    ctx: {};
    type: ProcedureType;
    path: string;
    input: {
        townName: string;
    };
    getRawInput: GetRawInputFn;
    meta: object | undefined;
    signal: AbortSignal | undefined;
    batchIndex: number;
    next: {
        (): Promise<MiddlewareResult<object>>;
        <$ContextOverride>(opts: {
            ctx?: $ContextOverride | undefined;
            input?: unknown;
        }): Promise<MiddlewareResult<$ContextOverride>>;
        (opts: {
            getRawInput: GetRawInputFn;
        }): Promise<...>;
    };
}
opts.
input: {
    townName: string;
}
input;
          
const input: {
    townName: string;
}

    var console: Consoleconsole.Console.log(...data: any[]): voidlog(`Handling request with user from: ${
const input: {
    townName: string;
}
input.townName: stringtownName}`);

    return 
opts: {
    ctx: {};
    type: ProcedureType;
    path: string;
    input: {
        townName: string;
    };
    getRawInput: GetRawInputFn;
    meta: object | undefined;
    signal: AbortSignal | undefined;
    batchIndex: number;
    next: {
        (): Promise<MiddlewareResult<object>>;
        <$ContextOverride>(opts: {
            ctx?: $ContextOverride | undefined;
            input?: unknown;
        }): Promise<MiddlewareResult<$ContextOverride>>;
        (opts: {
            getRawInput: GetRawInputFn;
        }): Promise<...>;
    };
}
opts.next: () => Promise<MiddlewareResult<object>> (+2 overloads)next();
  });

export const 
const appRouter: BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            townName: string;
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
appRouter = 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t.
TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, { ctx: object; meta: object; errorShape: DefaultErrorShape; transformer: false; }>.router: RouterBuilder
<{
    hello: QueryProcedure<{
        input: {
            townName: string;
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>(_: {
    hello: QueryProcedure<{
        input: {
            townName: string;
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}) => BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            townName: string;
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
router({
  
hello: QueryProcedure<{
    input: {
        townName: string;
        name: string;
    };
    output: {
        greeting: string;
    };
    meta: object;
    errorShape: DefaultErrorShape;
}>
hello: 
const baseProcedure: ProcedureBuilder<object, object, {}, {
    townName: string;
}, {
    townName: string;
}, UnsetMarker, UnsetMarker, false, DefaultErrorShape>
baseProcedure
    .
ProcedureBuilder<object, object, {}, { townName: string; }, { townName: string; }, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.input<z.ZodObject<{
    name: z.ZodString;
}, z.core.$strip>>(schema: z.ZodObject<{
    name: z.ZodString;
}, z.core.$strip>): ProcedureBuilder<object, object, {}, {
    townName: string;
    name: string;
}, {
    townName: string;
    name: string;
}, UnsetMarker, UnsetMarker, false, DefaultErrorShape>
input(
      import zz.
function object<{
    name: z.ZodString;
}>(shape?: {
    name: z.ZodString;
} | undefined, params?: string | {
    error?: string | z.core.$ZodErrorMap<NonNullable<z.core.$ZodIssueUnrecognizedKeys | z.core.$ZodIssueInvalidType<unknown>>> | undefined;
    message?: string | undefined | undefined;
} | undefined): z.ZodObject<{
    name: z.ZodString;
}, z.core.$strip>
object({
        name: z.ZodStringname: import zz.function string(params?: string | z.core.$ZodStringParams): z.ZodString (+1 overload)string(),
      }),
    )
    .
ProcedureBuilder<object, object, {}, { townName: string; name: string; }, { townName: string; name: string; }, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.query<{
    greeting: string;
}>(resolver: ProcedureResolver<object, object, {}, {
    townName: string;
    name: string;
}, UnsetMarker, {
    greeting: string;
}>): QueryProcedure<{
    input: {
        townName: string;
        name: string;
    };
    output: {
        greeting: string;
    };
    meta: object;
    errorShape: DefaultErrorShape;
}>
query((
opts: ProcedureResolverOptions<object, object, {}, {
    townName: string;
    name: string;
}>
opts) => {
      const input = 
opts: ProcedureResolverOptions<object, object, {}, {
    townName: string;
    name: string;
}>
opts.
ProcedureResolverOptions<object, object, {}, { townName: string; name: string; }>.input: {
    townName: string;
    name: string;
}
input;
            
const input: {
    townName: string;
    name: string;
}
      return {
        greeting: stringgreeting: `Hello ${
const input: {
    townName: string;
    name: string;
}
input.name: stringname}, my friend from ${
const input: {
    townName: string;
    name: string;
}
input.townName: stringtownName}`,
      };
    }),
});

Output Validators

Validating outputs is not always as important as defining inputs, since tRPC gives you automatic type-safety by inferring the return type of your procedures. Some reasons to define an output validator include:

  • Checking that data returned from untrusted sources is correct
  • Ensure that you are not returning more data to the client than necessary

import { import zz } from 'zod';

export const 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t = const initTRPC: TRPCBuilder<object, object>initTRPC.
TRPCBuilder<object, object>.create<RuntimeConfigOptions<object, object>>(opts?: RuntimeConfigOptions<object, object> | undefined): TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
create();
const const publicProcedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>publicProcedure = 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t.TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, { ctx: object; meta: object; errorShape: DefaultErrorShape; transformer: false; }>.procedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>procedure;

export const 
const appRouter: BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: void;
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
appRouter = 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t.
TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, { ctx: object; meta: object; errorShape: DefaultErrorShape; transformer: false; }>.router: RouterBuilder
<{
    hello: QueryProcedure<{
        input: void;
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>(_: {
    hello: QueryProcedure<{
        input: void;
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}) => BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: void;
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
router({
  
hello: QueryProcedure<{
    input: void;
    output: {
        greeting: string;
    };
    meta: object;
    errorShape: DefaultErrorShape;
}>
hello: const publicProcedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>publicProcedure
    .
ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.output<z.ZodObject<{
    greeting: z.ZodString;
}, z.core.$strip>>(schema: z.ZodObject<{
    greeting: z.ZodString;
}, z.core.$strip>): ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, {
    greeting: string;
}, {
    greeting: string;
}, false, DefaultErrorShape>
output(
      import zz.
function object<{
    greeting: z.ZodString;
}>(shape?: {
    greeting: z.ZodString;
} | undefined, params?: string | {
    error?: string | z.core.$ZodErrorMap<NonNullable<z.core.$ZodIssueUnrecognizedKeys | z.core.$ZodIssueInvalidType<unknown>>> | undefined;
    message?: string | undefined | undefined;
} | undefined): z.ZodObject<{
    greeting: z.ZodString;
}, z.core.$strip>
object({
        greeting: z.ZodStringgreeting: import zz.function string(params?: string | z.core.$ZodStringParams): z.ZodString (+1 overload)string(),
      }),
    )
    .
ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, { greeting: string; }, { greeting: string; }, false, DefaultErrorShape>.query<unknown>(resolver: ProcedureResolver<object, object, object, UnsetMarker, {
    greeting: string;
}, unknown>): QueryProcedure<{
    input: void;
    output: {
        greeting: string;
    };
    meta: object;
    errorShape: DefaultErrorShape;
}>
query((opts: ProcedureResolverOptions<object, object, object, UnsetMarker>opts) => {
      return {
        greeting: 'hello world',
          
greeting: string
      };
    }),
});

Output validation of subscriptions

Since subscriptions are async iterators, you can use the same validation techniques as above.

Have a look at the subscriptions guide for more information.

The most basic validator: a function

You can define a validator without any 3rd party dependencies, with a function.

import { const initTRPC: TRPCBuilder<object, object>initTRPC } from '@trpc/server';

export const 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t = const initTRPC: TRPCBuilder<object, object>initTRPC.
TRPCBuilder<object, object>.create<RuntimeConfigOptions<object, object>>(opts?: RuntimeConfigOptions<object, object> | undefined): TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
create();

const const publicProcedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>publicProcedure = 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t.TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, { ctx: object; meta: object; errorShape: DefaultErrorShape; transformer: false; }>.procedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>procedure;

export const 
const appRouter: BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: string;
        output: string;
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
appRouter = 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t.
TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, { ctx: object; meta: object; errorShape: DefaultErrorShape; transformer: false; }>.router: RouterBuilder
<{
    hello: QueryProcedure<{
        input: string;
        output: string;
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>(_: {
    hello: QueryProcedure<{
        input: string;
        output: string;
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}) => BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: string;
        output: string;
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
router({
  
hello: QueryProcedure<{
    input: string;
    output: string;
    meta: object;
    errorShape: DefaultErrorShape;
}>
hello: const publicProcedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>publicProcedure
    .ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.input<(value: unknown) => string>(schema: (value: unknown) => string): ProcedureBuilder<object, object, object, string, string, UnsetMarker, UnsetMarker, false, DefaultErrorShape>input((value: unknownvalue): string => {
      if (typeof value: unknownvalue === 'string') {
        return value: stringvalue;
      }
      throw new 
var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+1 overload)
Error('Input is not a string');
    })
    .ProcedureBuilder<object, object, object, string, string, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.output<(value: unknown) => string>(schema: (value: unknown) => string): ProcedureBuilder<object, object, object, string, string, string, string, false, DefaultErrorShape>output((value: unknownvalue): string => {
      if (typeof value: unknownvalue === 'string') {
        return value: stringvalue;
      }
      throw new 
var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+1 overload)
Error('Output is not a string');
    })
    .
ProcedureBuilder<object, object, object, string, string, string, string, false, DefaultErrorShape>.query<unknown>(resolver: ProcedureResolver<object, object, object, string, string, unknown>): QueryProcedure<{
    input: string;
    output: string;
    meta: object;
    errorShape: DefaultErrorShape;
}>
query((opts: ProcedureResolverOptions<object, object, object, string>opts) => {
      const { input } = opts: ProcedureResolverOptions<object, object, object, string>opts;
              
const input: string
      return `hello ${const input: stringinput}`;
    }),
});

export type 
type AppRouter = Router<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: string;
        output: string;
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>> & DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: string;
        output: string;
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>
AppRouter = typeof 
const appRouter: BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: string;
        output: string;
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
appRouter;

Library integrations

tRPC works out of the box with a number of popular validation and parsing libraries, including any library conforming to Standard Schema. The below are some examples of usage with validators which we officially maintain support for.

With Zod

Zod is our default recommendation, it has a strong ecosystem which makes it a great choice to use in multiple parts of your codebase. If you have no opinion of your own and want a powerful library which won't limit future needs, Zod is a great choice.

import { const initTRPC: TRPCBuilder<object, object>initTRPC } from '@trpc/server';
import { import zz } from 'zod';

export const 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t = const initTRPC: TRPCBuilder<object, object>initTRPC.
TRPCBuilder<object, object>.create<RuntimeConfigOptions<object, object>>(opts?: RuntimeConfigOptions<object, object> | undefined): TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
create();

const const publicProcedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>publicProcedure = 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t.TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, { ctx: object; meta: object; errorShape: DefaultErrorShape; transformer: false; }>.procedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>procedure;

export const 
const appRouter: BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
appRouter = 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t.
TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, { ctx: object; meta: object; errorShape: DefaultErrorShape; transformer: false; }>.router: RouterBuilder
<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>(_: {
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}) => BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
router({
  
hello: QueryProcedure<{
    input: {
        name: string;
    };
    output: {
        greeting: string;
    };
    meta: object;
    errorShape: DefaultErrorShape;
}>
hello: const publicProcedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>publicProcedure
    .
ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.input<z.ZodObject<{
    name: z.ZodString;
}, z.core.$strip>>(schema: z.ZodObject<{
    name: z.ZodString;
}, z.core.$strip>): ProcedureBuilder<object, object, object, {
    name: string;
}, {
    name: string;
}, UnsetMarker, UnsetMarker, false, DefaultErrorShape>
input(
      import zz.
function object<{
    name: z.ZodString;
}>(shape?: {
    name: z.ZodString;
} | undefined, params?: string | {
    error?: string | z.core.$ZodErrorMap<NonNullable<z.core.$ZodIssueUnrecognizedKeys | z.core.$ZodIssueInvalidType<unknown>>> | undefined;
    message?: string | undefined | undefined;
} | undefined): z.ZodObject<{
    name: z.ZodString;
}, z.core.$strip>
object({
        name: z.ZodStringname: import zz.function string(params?: string | z.core.$ZodStringParams): z.ZodString (+1 overload)string(),
      }),
    )
    .
ProcedureBuilder<object, object, object, { name: string; }, { name: string; }, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.output<z.ZodObject<{
    greeting: z.ZodString;
}, z.core.$strip>>(schema: z.ZodObject<{
    greeting: z.ZodString;
}, z.core.$strip>): ProcedureBuilder<object, object, object, {
    name: string;
}, {
    name: string;
}, {
    greeting: string;
}, {
    greeting: string;
}, false, DefaultErrorShape>
output(
      import zz.
function object<{
    greeting: z.ZodString;
}>(shape?: {
    greeting: z.ZodString;
} | undefined, params?: string | {
    error?: string | z.core.$ZodErrorMap<NonNullable<z.core.$ZodIssueUnrecognizedKeys | z.core.$ZodIssueInvalidType<unknown>>> | undefined;
    message?: string | undefined | undefined;
} | undefined): z.ZodObject<{
    greeting: z.ZodString;
}, z.core.$strip>
object({
        greeting: z.ZodStringgreeting: import zz.function string(params?: string | z.core.$ZodStringParams): z.ZodString (+1 overload)string(),
      }),
    )
    .
ProcedureBuilder<object, object, object, { name: string; }, { name: string; }, { greeting: string; }, { greeting: string; }, false, DefaultErrorShape>.query<unknown>(resolver: ProcedureResolver<object, object, object, {
    name: string;
}, {
    greeting: string;
}, unknown>): QueryProcedure<{
    input: {
        name: string;
    };
    output: {
        greeting: string;
    };
    meta: object;
    errorShape: DefaultErrorShape;
}>
query(({ input }) => {
              
input: {
    name: string;
}
      return {
        greeting: stringgreeting: `hello ${
input: {
    name: string;
}
input.name: stringname}`,
      };
    }),
});

export type 
type AppRouter = Router<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>> & DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>
AppRouter = typeof 
const appRouter: BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
appRouter;

With Yup

import { const initTRPC: TRPCBuilder<object, object>initTRPC } from '@trpc/server';
import * as import yupyup from 'yup';

export const 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t = const initTRPC: TRPCBuilder<object, object>initTRPC.
TRPCBuilder<object, object>.create<RuntimeConfigOptions<object, object>>(opts?: RuntimeConfigOptions<object, object> | undefined): TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
create();

const const publicProcedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>publicProcedure = 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t.TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, { ctx: object; meta: object; errorShape: DefaultErrorShape; transformer: false; }>.procedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>procedure;

export const 
const appRouter: BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
appRouter = 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t.
TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, { ctx: object; meta: object; errorShape: DefaultErrorShape; transformer: false; }>.router: RouterBuilder
<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>(_: {
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}) => BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
router({
  
hello: QueryProcedure<{
    input: {
        name: string;
    };
    output: {
        greeting: string;
    };
    meta: object;
    errorShape: DefaultErrorShape;
}>
hello: const publicProcedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>publicProcedure
    .
ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.input<yup.ObjectSchema<{
    name: string;
}, yup.AnyObject, {
    name: undefined;
}, "">>(schema: yup.ObjectSchema<{
    name: string;
}, yup.AnyObject, {
    name: undefined;
}, "">): ProcedureBuilder<object, object, object, {
    name: string;
}, {
    name: string;
}, UnsetMarker, UnsetMarker, false, DefaultErrorShape>
input(
      import yupyup.
object<yup.AnyObject, {
    name: yup.StringSchema<string, yup.AnyObject, undefined, "">;
}>(spec?: {
    name: yup.StringSchema<string, yup.AnyObject, undefined, "">;
} | undefined): yup.ObjectSchema<{
    name: string;
}, yup.AnyObject, {
    name: undefined;
}, "">
export object
object({
        name: yup.StringSchema<string, yup.AnyObject, undefined, "">name: import yupyup.
function string(): yup.StringSchema (+1 overload)
export string
string().StringSchema<string | undefined, AnyObject, undefined, "">.required(msg?: yup.Message): yup.StringSchema<string, yup.AnyObject, undefined, "">required(),
      }),
    )
    .
ProcedureBuilder<object, object, object, { name: string; }, { name: string; }, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.output<yup.ObjectSchema<{
    greeting: string;
}, yup.AnyObject, {
    greeting: undefined;
}, "">>(schema: yup.ObjectSchema<{
    greeting: string;
}, yup.AnyObject, {
    greeting: undefined;
}, "">): ProcedureBuilder<object, object, object, {
    name: string;
}, {
    name: string;
}, {
    greeting: string;
}, {
    greeting: string;
}, false, DefaultErrorShape>
output(
      import yupyup.
object<yup.AnyObject, {
    greeting: yup.StringSchema<string, yup.AnyObject, undefined, "">;
}>(spec?: {
    greeting: yup.StringSchema<string, yup.AnyObject, undefined, "">;
} | undefined): yup.ObjectSchema<{
    greeting: string;
}, yup.AnyObject, {
    greeting: undefined;
}, "">
export object
object({
        greeting: yup.StringSchema<string, yup.AnyObject, undefined, "">greeting: import yupyup.
function string(): yup.StringSchema (+1 overload)
export string
string().StringSchema<string | undefined, AnyObject, undefined, "">.required(msg?: yup.Message): yup.StringSchema<string, yup.AnyObject, undefined, "">required(),
      }),
    )
    .
ProcedureBuilder<object, object, object, { name: string; }, { name: string; }, { greeting: string; }, { greeting: string; }, false, DefaultErrorShape>.query<unknown>(resolver: ProcedureResolver<object, object, object, {
    name: string;
}, {
    greeting: string;
}, unknown>): QueryProcedure<{
    input: {
        name: string;
    };
    output: {
        greeting: string;
    };
    meta: object;
    errorShape: DefaultErrorShape;
}>
query(({ input }) => {
              
input: {
    name: string;
}
      return {
        greeting: stringgreeting: `hello ${
input: {
    name: string;
}
input.name: stringname}`,
      };
    }),
});

export type 
type AppRouter = Router<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>> & DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>
AppRouter = typeof 
const appRouter: BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
appRouter;

With Superstruct

import { const initTRPC: TRPCBuilder<object, object>initTRPC } from '@trpc/server';
import { function object(): Struct<Record<string, unknown>, null> (+1 overload)object, function string(): Struct<string, null>string } from 'superstruct';

export const 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t = const initTRPC: TRPCBuilder<object, object>initTRPC.
TRPCBuilder<object, object>.create<RuntimeConfigOptions<object, object>>(opts?: RuntimeConfigOptions<object, object> | undefined): TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
create();

const const publicProcedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>publicProcedure = 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t.TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, { ctx: object; meta: object; errorShape: DefaultErrorShape; transformer: false; }>.procedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>procedure;

export const 
const appRouter: BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
appRouter = 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t.
TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, { ctx: object; meta: object; errorShape: DefaultErrorShape; transformer: false; }>.router: RouterBuilder
<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>(_: {
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}) => BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
router({
  
hello: QueryProcedure<{
    input: {
        name: string;
    };
    output: {
        greeting: string;
    };
    meta: object;
    errorShape: DefaultErrorShape;
}>
hello: const publicProcedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>publicProcedure
    .
ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.input<Struct<{
    name: string;
}, {
    name: Struct<string, null>;
}>>(schema: Struct<{
    name: string;
}, {
    name: Struct<string, null>;
}>): ProcedureBuilder<object, object, object, {
    name: string;
}, {
    name: string;
}, UnsetMarker, UnsetMarker, false, DefaultErrorShape>
input(
object<{
    name: Struct<string, null>;
}>(schema: {
    name: Struct<string, null>;
}): Struct<{
    name: string;
}, {
    name: Struct<string, null>;
}> (+1 overload)
object({ name: Struct<string, null>name: function string(): Struct<string, null>string() }))
    .
ProcedureBuilder<object, object, object, { name: string; }, { name: string; }, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.output<Struct<{
    greeting: string;
}, {
    greeting: Struct<string, null>;
}>>(schema: Struct<{
    greeting: string;
}, {
    greeting: Struct<string, null>;
}>): ProcedureBuilder<object, object, object, {
    name: string;
}, {
    name: string;
}, {
    greeting: string;
}, {
    greeting: string;
}, false, DefaultErrorShape>
output(
object<{
    greeting: Struct<string, null>;
}>(schema: {
    greeting: Struct<string, null>;
}): Struct<{
    greeting: string;
}, {
    greeting: Struct<string, null>;
}> (+1 overload)
object({ greeting: Struct<string, null>greeting: function string(): Struct<string, null>string() }))
    .
ProcedureBuilder<object, object, object, { name: string; }, { name: string; }, { greeting: string; }, { greeting: string; }, false, DefaultErrorShape>.query<unknown>(resolver: ProcedureResolver<object, object, object, {
    name: string;
}, {
    greeting: string;
}, unknown>): QueryProcedure<{
    input: {
        name: string;
    };
    output: {
        greeting: string;
    };
    meta: object;
    errorShape: DefaultErrorShape;
}>
query(({ input }) => {
              
input: {
    name: string;
}
      return {
        greeting: stringgreeting: `hello ${
input: {
    name: string;
}
input.name: stringname}`,
      };
    }),
});

export type 
type AppRouter = Router<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>> & DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>
AppRouter = typeof 
const appRouter: BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
appRouter;

With scale-ts

import { const initTRPC: TRPCBuilder<object, object>initTRPC } from '@trpc/server';
import * as import $$ from 'scale-codec';

export const 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t = const initTRPC: TRPCBuilder<object, object>initTRPC.
TRPCBuilder<object, object>.create<RuntimeConfigOptions<object, object>>(opts?: RuntimeConfigOptions<object, object> | undefined): TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
create();

const const publicProcedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>publicProcedure = 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t.TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, { ctx: object; meta: object; errorShape: DefaultErrorShape; transformer: false; }>.procedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>procedure;

export const 
const appRouter: BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            readonly name: string;
        };
        output: {
            readonly greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
appRouter = 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t.
TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, { ctx: object; meta: object; errorShape: DefaultErrorShape; transformer: false; }>.router: RouterBuilder
<{
    hello: QueryProcedure<{
        input: {
            readonly name: string;
        };
        output: {
            readonly greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>(_: {
    hello: QueryProcedure<{
        input: {
            readonly name: string;
        };
        output: {
            readonly greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}) => BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            readonly name: string;
        };
        output: {
            readonly greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
router({
  
hello: QueryProcedure<{
    input: {
        readonly name: string;
    };
    output: {
        readonly greeting: string;
    };
    meta: object;
    errorShape: DefaultErrorShape;
}>
hello: const publicProcedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>publicProcedure
    .
ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.input<$.Codec<{
    readonly name: string;
}, {
    name: string;
}>>(schema: $.Codec<{
    readonly name: string;
}, {
    name: string;
}>): ProcedureBuilder<object, object, object, {
    readonly name: string;
}, {
    readonly name: string;
}, UnsetMarker, UnsetMarker, false, DefaultErrorShape>
input(import $$.
function object<[$.Codec<{
    readonly name: string;
}, {
    name: string;
}>]>(members_0: $.Codec<{
    readonly name: string;
}, {
    readonly name: string;
}>): $.Codec<{
    readonly name: string;
}, {
    name: string;
}>
object(import $$.
function field<"name", string, string>(key: "name", $value: $.Codec<string, string>): $.Codec<{
    readonly name: string;
}, {
    name: string;
}>
field('name', import $$.const str: $.Codec<string, string>str)))
    .
ProcedureBuilder<object, object, object, { readonly name: string; }, { readonly name: string; }, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.output<$.Codec<{
    readonly greeting: string;
}, {
    greeting: string;
}>>(schema: $.Codec<{
    readonly greeting: string;
}, {
    greeting: string;
}>): ProcedureBuilder<object, object, object, {
    readonly name: string;
}, {
    readonly name: string;
}, {
    readonly greeting: string;
}, {
    readonly greeting: string;
}, false, DefaultErrorShape>
output(import $$.
function object<[$.Codec<{
    readonly greeting: string;
}, {
    greeting: string;
}>]>(members_0: $.Codec<{
    readonly greeting: string;
}, {
    readonly greeting: string;
}>): $.Codec<{
    readonly greeting: string;
}, {
    greeting: string;
}>
object(import $$.
function field<"greeting", string, string>(key: "greeting", $value: $.Codec<string, string>): $.Codec<{
    readonly greeting: string;
}, {
    greeting: string;
}>
field('greeting', import $$.const str: $.Codec<string, string>str)))
    .
ProcedureBuilder<object, object, object, { readonly name: string; }, { readonly name: string; }, { readonly greeting: string; }, { readonly greeting: string; }, false, DefaultErrorShape>.query<unknown>(resolver: ProcedureResolver<object, object, object, {
    readonly name: string;
}, {
    readonly greeting: string;
}, unknown>): QueryProcedure<{
    input: {
        readonly name: string;
    };
    output: {
        readonly greeting: string;
    };
    meta: object;
    errorShape: DefaultErrorShape;
}>
query(({ input }) => {
              
input: {
    readonly name: string;
}
      return {
        greeting: stringgreeting: `hello ${
input: {
    readonly name: string;
}
input.name: stringname}`,
      };
    }),
});

export type 
type AppRouter = Router<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            readonly name: string;
        };
        output: {
            readonly greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>> & DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            readonly name: string;
        };
        output: {
            readonly greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>
AppRouter = typeof 
const appRouter: BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            readonly name: string;
        };
        output: {
            readonly greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
appRouter;

With Typia

import { initTRPC } from '@trpc/server';
import typia from 'typia';
import { v4 } from 'uuid';
import { IBbsArticle } from '../structures/IBbsArticle';

const t = initTRPC.create();

const publicProcedure = t.procedure;

export const appRouter = t.router({
  store: publicProcedure
    .input(typia.createAssert<IBbsArticle.IStore>())
    .output(typia.createAssert<IBbsArticle>())
    .query(({ input }) => {
      return {
        id: v4(),
        writer: input.writer,
        title: input.title,
        body: input.body,
        created_at: new Date().toString(),
      };
    }),
});

export type AppRouter = typeof appRouter;

With ArkType

import { initTRPC } from '@trpc/server';
import { type } from 'arktype';

export const t = initTRPC.create();

const publicProcedure = t.procedure;

export const appRouter = t.router({
  hello: publicProcedure.input(type({ name: 'string' })).query((opts) => {
    return {
      greeting: `hello ${opts.input.name}`,
    };
  }),
});

export type AppRouter = typeof appRouter;

With effect

import { const initTRPC: TRPCBuilder<object, object>initTRPC } from '@trpc/server';
import { import SchemaSchema } from 'effect';

export const 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t = const initTRPC: TRPCBuilder<object, object>initTRPC.
TRPCBuilder<object, object>.create<RuntimeConfigOptions<object, object>>(opts?: RuntimeConfigOptions<object, object> | undefined): TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
create();

const const publicProcedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>publicProcedure = 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t.TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, { ctx: object; meta: object; errorShape: DefaultErrorShape; transformer: false; }>.procedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>procedure;

export const 
const appRouter: BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            readonly name: string;
        };
        output: {
            readonly greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
appRouter = 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t.
TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, { ctx: object; meta: object; errorShape: DefaultErrorShape; transformer: false; }>.router: RouterBuilder
<{
    hello: QueryProcedure<{
        input: {
            readonly name: string;
        };
        output: {
            readonly greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>(_: {
    hello: QueryProcedure<{
        input: {
            readonly name: string;
        };
        output: {
            readonly greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}) => BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            readonly name: string;
        };
        output: {
            readonly greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
router({
  
hello: QueryProcedure<{
    input: {
        readonly name: string;
    };
    output: {
        readonly greeting: string;
    };
    meta: object;
    errorShape: DefaultErrorShape;
}>
hello: const publicProcedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>publicProcedure
    .
ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.input<StandardSchemaV1<{
    readonly name: string;
}, {
    readonly name: string;
}> & Schema.SchemaClass<{
    readonly name: string;
}, {
    readonly name: string;
}, never>>(schema: StandardSchemaV1<{
    readonly name: string;
}, {
    readonly name: string;
}> & Schema.SchemaClass<{
    readonly name: string;
}, {
    readonly name: string;
}, never>): ProcedureBuilder<object, object, object, {
    readonly name: string;
}, {
    readonly name: string;
}, UnsetMarker, UnsetMarker, false, DefaultErrorShape>
input(import SchemaSchema.
const standardSchemaV1: <{
    readonly name: string;
}, {
    readonly name: string;
}>(schema: Schema.Schema<{
    readonly name: string;
}, {
    readonly name: string;
}, never>, overrideOptions?: ParseOptions) => StandardSchemaV1<{
    readonly name: string;
}, {
    readonly name: string;
}> & Schema.SchemaClass<{
    readonly name: string;
}, {
    readonly name: string;
}, never>
standardSchemaV1(import SchemaSchema.
function Struct<{
    name: typeof Schema.String;
}>(fields: {
    name: typeof Schema.String;
}): Schema.Struct<{
    name: typeof Schema.String;
}> (+1 overload)
Struct({ name: typeof Schema.Stringname: import SchemaSchema.
class String
export String
String })))
    .
ProcedureBuilder<object, object, object, { readonly name: string; }, { readonly name: string; }, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.output<StandardSchemaV1<{
    readonly greeting: string;
}, {
    readonly greeting: string;
}> & Schema.SchemaClass<{
    readonly greeting: string;
}, {
    readonly greeting: string;
}, never>>(schema: StandardSchemaV1<{
    readonly greeting: string;
}, {
    readonly greeting: string;
}> & Schema.SchemaClass<{
    readonly greeting: string;
}, {
    readonly greeting: string;
}, never>): ProcedureBuilder<object, object, object, {
    readonly name: string;
}, {
    readonly name: string;
}, {
    readonly greeting: string;
}, {
    readonly greeting: string;
}, false, DefaultErrorShape>
output(import SchemaSchema.
const standardSchemaV1: <{
    readonly greeting: string;
}, {
    readonly greeting: string;
}>(schema: Schema.Schema<{
    readonly greeting: string;
}, {
    readonly greeting: string;
}, never>, overrideOptions?: ParseOptions) => StandardSchemaV1<{
    readonly greeting: string;
}, {
    readonly greeting: string;
}> & Schema.SchemaClass<{
    readonly greeting: string;
}, {
    readonly greeting: string;
}, never>
standardSchemaV1(import SchemaSchema.
function Struct<{
    greeting: typeof Schema.String;
}>(fields: {
    greeting: typeof Schema.String;
}): Schema.Struct<{
    greeting: typeof Schema.String;
}> (+1 overload)
Struct({ greeting: typeof Schema.Stringgreeting: import SchemaSchema.
class String
export String
String })))
    .
ProcedureBuilder<object, object, object, { readonly name: string; }, { readonly name: string; }, { readonly greeting: string; }, { readonly greeting: string; }, false, DefaultErrorShape>.query<unknown>(resolver: ProcedureResolver<object, object, object, {
    readonly name: string;
}, {
    readonly greeting: string;
}, unknown>): QueryProcedure<{
    input: {
        readonly name: string;
    };
    output: {
        readonly greeting: string;
    };
    meta: object;
    errorShape: DefaultErrorShape;
}>
query(({ input }) => {
              
input: {
    readonly name: string;
}
      return {
        greeting: stringgreeting: `hello ${
input: {
    readonly name: string;
}
input.name: stringname}`,
      };
    }),
});

export type 
type AppRouter = Router<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            readonly name: string;
        };
        output: {
            readonly greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>> & DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            readonly name: string;
        };
        output: {
            readonly greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>
AppRouter = typeof 
const appRouter: BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            readonly name: string;
        };
        output: {
            readonly greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
appRouter;

With Valibot

import { const initTRPC: TRPCBuilder<object, object>initTRPC } from '@trpc/server';
import * as import vv from 'valibot';

export const 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t = const initTRPC: TRPCBuilder<object, object>initTRPC.
TRPCBuilder<object, object>.create<RuntimeConfigOptions<object, object>>(opts?: RuntimeConfigOptions<object, object> | undefined): TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
create();

const const publicProcedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>publicProcedure = 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t.TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, { ctx: object; meta: object; errorShape: DefaultErrorShape; transformer: false; }>.procedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>procedure;

export const 
const appRouter: BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
appRouter = 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t.
TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, { ctx: object; meta: object; errorShape: DefaultErrorShape; transformer: false; }>.router: RouterBuilder
<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>(_: {
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}) => BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
router({
  
hello: QueryProcedure<{
    input: {
        name: string;
    };
    output: {
        greeting: string;
    };
    meta: object;
    errorShape: DefaultErrorShape;
}>
hello: const publicProcedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>publicProcedure
    .
ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.input<v.ObjectSchema<{
    readonly name: v.StringSchema<undefined>;
}, undefined>>(schema: v.ObjectSchema<{
    readonly name: v.StringSchema<undefined>;
}, undefined>): ProcedureBuilder<object, object, object, {
    name: string;
}, {
    name: string;
}, UnsetMarker, UnsetMarker, false, DefaultErrorShape>
input(import vv.
object<{
    readonly name: v.StringSchema<undefined>;
}>(entries: {
    readonly name: v.StringSchema<undefined>;
}): v.ObjectSchema<{
    readonly name: v.StringSchema<undefined>;
}, undefined> (+1 overload)
export object
object({ name: v.StringSchema<undefined>name: import vv.
function string(): v.StringSchema<undefined> (+1 overload)
export string
string() }))
    .
ProcedureBuilder<object, object, object, { name: string; }, { name: string; }, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.output<v.ObjectSchema<{
    readonly greeting: v.StringSchema<undefined>;
}, undefined>>(schema: v.ObjectSchema<{
    readonly greeting: v.StringSchema<undefined>;
}, undefined>): ProcedureBuilder<object, object, object, {
    name: string;
}, {
    name: string;
}, {
    greeting: string;
}, {
    greeting: string;
}, false, DefaultErrorShape>
output(import vv.
object<{
    readonly greeting: v.StringSchema<undefined>;
}>(entries: {
    readonly greeting: v.StringSchema<undefined>;
}): v.ObjectSchema<{
    readonly greeting: v.StringSchema<undefined>;
}, undefined> (+1 overload)
export object
object({ greeting: v.StringSchema<undefined>greeting: import vv.
function string(): v.StringSchema<undefined> (+1 overload)
export string
string() }))
    .
ProcedureBuilder<object, object, object, { name: string; }, { name: string; }, { greeting: string; }, { greeting: string; }, false, DefaultErrorShape>.query<unknown>(resolver: ProcedureResolver<object, object, object, {
    name: string;
}, {
    greeting: string;
}, unknown>): QueryProcedure<{
    input: {
        name: string;
    };
    output: {
        greeting: string;
    };
    meta: object;
    errorShape: DefaultErrorShape;
}>
query(({ input }) => {
              
input: {
    name: string;
}
      return {
        greeting: stringgreeting: `hello ${
input: {
    name: string;
}
input.name: stringname}`,
      };
    }),
});

export type 
type AppRouter = Router<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>> & DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>
AppRouter = typeof 
const appRouter: BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
appRouter;

With Sury

import { const initTRPC: TRPCBuilder<object, object>initTRPC } from '@trpc/server';
import * as import SS from 'sury';

export const 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t = const initTRPC: TRPCBuilder<object, object>initTRPC.
TRPCBuilder<object, object>.create<RuntimeConfigOptions<object, object>>(opts?: RuntimeConfigOptions<object, object> | undefined): TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
create();

const const publicProcedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>publicProcedure = 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t.TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, { ctx: object; meta: object; errorShape: DefaultErrorShape; transformer: false; }>.procedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>procedure;

export const 
const appRouter: BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
appRouter = 
const t: TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, {
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}>
t.
TRPCRootObject<object, object, RuntimeConfigOptions<object, object>, { ctx: object; meta: object; errorShape: DefaultErrorShape; transformer: false; }>.router: RouterBuilder
<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>(_: {
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}) => BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
router({
  
hello: QueryProcedure<{
    input: {
        name: string;
    };
    output: {
        greeting: string;
    };
    meta: object;
    errorShape: DefaultErrorShape;
}>
hello: const publicProcedure: ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>publicProcedure
    .
ProcedureBuilder<object, object, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.input<S.Schema<{
    name: string;
}, {
    name: string;
}>>(schema: S.Schema<{
    name: string;
}, {
    name: string;
}>): ProcedureBuilder<object, object, object, {
    name: string;
}, {
    name: string;
}, UnsetMarker, UnsetMarker, false, DefaultErrorShape>
input(import SS.
function schema<{
    readonly name: S.Schema<string, string>;
}>(value: {
    readonly name: S.Schema<string, string>;
}): S.Schema<{
    name: string;
}, {
    name: string;
}> (+1 overload)
schema({ name: S.Schema<string, string>name: import SS.const string: S.Schema<string, string>string }))
    .
ProcedureBuilder<object, object, object, { name: string; }, { name: string; }, UnsetMarker, UnsetMarker, false, DefaultErrorShape>.output<S.Schema<{
    greeting: string;
}, {
    greeting: string;
}>>(schema: S.Schema<{
    greeting: string;
}, {
    greeting: string;
}>): ProcedureBuilder<object, object, object, {
    name: string;
}, {
    name: string;
}, {
    greeting: string;
}, {
    greeting: string;
}, false, DefaultErrorShape>
output(import SS.
function schema<{
    readonly greeting: S.Schema<string, string>;
}>(value: {
    readonly greeting: S.Schema<string, string>;
}): S.Schema<{
    greeting: string;
}, {
    greeting: string;
}> (+1 overload)
schema({ greeting: S.Schema<string, string>greeting: import SS.const string: S.Schema<string, string>string }))
    .
ProcedureBuilder<object, object, object, { name: string; }, { name: string; }, { greeting: string; }, { greeting: string; }, false, DefaultErrorShape>.query<unknown>(resolver: ProcedureResolver<object, object, object, {
    name: string;
}, {
    greeting: string;
}, unknown>): QueryProcedure<{
    input: {
        name: string;
    };
    output: {
        greeting: string;
    };
    meta: object;
    errorShape: DefaultErrorShape;
}>
query(({ input }) => {
              
input: {
    name: string;
}
      return {
        greeting: stringgreeting: `hello ${
input: {
    name: string;
}
input.name: stringname}`,
      };
    }),
});

export type 
type AppRouter = Router<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>> & DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>
AppRouter = typeof 
const appRouter: BuiltRouter<{
    ctx: object;
    meta: object;
    errorShape: DefaultErrorShape;
    transformer: false;
}, DecorateCreateRouterOptions<{
    hello: QueryProcedure<{
        input: {
            name: string;
        };
        output: {
            greeting: string;
        };
        meta: object;
        errorShape: DefaultErrorShape;
    }>;
}>>
appRouter;

With @robolex/sure

You're able to define your own Error types and error throwing function if necessary. As a convenience @robolex/sure provides sure/src/err.ts:

// sure/src/err.ts
export const err = (schema: any) => (input: any) => {
  const [good, result] = schema(input);
  if (good) return result;
  throw result;
};
import { err, object, string } from '@robolex/sure';
import { initTRPC } from '@trpc/server';

export const t = initTRPC.create();

const publicProcedure = t.procedure;

export const appRouter = t.router({
  hello: publicProcedure
    .input(
      err(
        object({
          name: string,
        }),
      ),
    )
    .output(
      err(
        object({
          greeting: string,
        }),
      ),
    )
    .query(({ input }) => {
      //      ^?
      return {
        greeting: `hello ${input.name}`,
      };
    }),
});

export type AppRouter = typeof appRouter;

With TypeBox

import { Type } from '@sinclair/typebox';
import { initTRPC } from '@trpc/server';
import { wrap } from '@typeschema/typebox';

export const t = initTRPC.create();

const publicProcedure = t.procedure;

export const appRouter = t.router({
  hello: publicProcedure
    .input(wrap(Type.Object({ name: Type.String() })))
    .output(wrap(Type.Object({ greeting: Type.String() })))
    .query(({ input }) => {
      return {
        greeting: `hello ${input.name}`,
      };
    }),
});

export type AppRouter = typeof appRouter;

Contributing your own Validator Library

If you work on a validator library which supports tRPC usage, please feel free to open a PR for this page with equivalent usage to the other examples here, and a link to your docs.

Integration with tRPC in most cases is as simple as meeting one of several existing type interfaces. Conforming to Standard Schema is recommended, but in some cases we may accept a PR to add a new supported interface. Feel free to open an issue for discussion. You can check the existing supported interfaces and functions for parsing/validation in code.