@m5kdev/frontend 0.8.7 → 0.8.8

package/dist/node_modules/.pnpm/@trpc_server@11.4.3_typescript@5.9.2/node_modules/@trpc/server/dist/unstable-core-do-not-import.d-ClFRzVsT.d.ts

@@ -0,0 +1,912 @@
+import { Observable, inferObservableValue } from "./index.d-D4qZxQJh.js";
+
+//#region ../../node_modules/.pnpm/@trpc+server@11.4.3_typescript@5.9.2/node_modules/@trpc/server/dist/unstable-core-do-not-import.d-ClFRzVsT.d.mts
+/**
+ * @internal
+ * @see https://github.com/ianstormtaylor/superstruct/blob/7973400cd04d8ad92bbdc2b6f35acbfb3c934079/src/utils.ts#L323-L325
+ */
+type Simplify<TType> = TType extends any[] | Date ? TType : { [K in keyof TType]: TType[K] };
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+type MaybePromise<TType> = Promise<TType> | TType;
+/**
+ * See https://github.com/microsoft/TypeScript/issues/41966#issuecomment-758187996
+ * Fixes issues with iterating over keys of objects with index signatures.
+ * Without this, iterations over keys of objects with index signatures will lose
+ * type information about the keys and only the index signature will remain.
+ * @internal
+ */
+type WithoutIndexSignature<TObj> = { [K in keyof TObj as string extends K ? never : number extends K ? never : K]: TObj[K] };
+/**
+ * @internal
+ * Overwrite properties in `TType` with properties in `TWith`
+ * Only overwrites properties when the type to be overwritten
+ * is an object. Otherwise it will just use the type from `TWith`.
+ */
+type Overwrite<TType, TWith> = TWith extends any ? TType extends object ? { [K in keyof WithoutIndexSignature<TType> | keyof WithoutIndexSignature<TWith>]: K extends keyof TWith ? TWith[K] : K extends keyof TType ? TType[K] : never } & (string extends keyof TWith ? {
+  [key: string]: TWith[string];
+} : number extends keyof TWith ? {
+  [key: number]: TWith[number];
+} : {}) : TWith : never;
+/**
+ * @internal
+ */
+/**
+ * @internal
+ * Returns the raw input type of a procedure
+ */
+type GetRawInputFn = () => Promise<unknown>;
+declare const _errorSymbol: unique symbol;
+type TypeError<TMessage extends string> = TMessage & {
+  _: typeof _errorSymbol;
+};
+type ValueOf<TObj> = TObj[keyof TObj];
+//#endregion
+//#region src/unstable-core-do-not-import/rpc/codes.d.ts
+/**
+ * JSON-RPC 2.0 Error codes
+ *
+ * `-32000` to `-32099` are reserved for implementation-defined server-errors.
+ * For tRPC we're copying the last digits of HTTP 4XX errors.
+ */
+declare const TRPC_ERROR_CODES_BY_KEY: {
+  /**
+   * Invalid JSON was received by the server.
+   * An error occurred on the server while parsing the JSON text.
+   */
+  readonly PARSE_ERROR: -32700;
+  /**
+   * The JSON sent is not a valid Request object.
+   */
+  readonly BAD_REQUEST: -32600;
+  readonly INTERNAL_SERVER_ERROR: -32603;
+  readonly NOT_IMPLEMENTED: -32603;
+  readonly BAD_GATEWAY: -32603;
+  readonly SERVICE_UNAVAILABLE: -32603;
+  readonly GATEWAY_TIMEOUT: -32603;
+  readonly UNAUTHORIZED: -32001;
+  readonly PAYMENT_REQUIRED: -32002;
+  readonly FORBIDDEN: -32003;
+  readonly NOT_FOUND: -32004;
+  readonly METHOD_NOT_SUPPORTED: -32005;
+  readonly TIMEOUT: -32008;
+  readonly CONFLICT: -32009;
+  readonly PRECONDITION_FAILED: -32012;
+  readonly PAYLOAD_TOO_LARGE: -32013;
+  readonly UNSUPPORTED_MEDIA_TYPE: -32015;
+  readonly UNPROCESSABLE_CONTENT: -32022;
+  readonly TOO_MANY_REQUESTS: -32029;
+  readonly CLIENT_CLOSED_REQUEST: -32099;
+};
+type TRPC_ERROR_CODE_NUMBER = ValueOf<typeof TRPC_ERROR_CODES_BY_KEY>;
+type TRPC_ERROR_CODE_KEY = keyof typeof TRPC_ERROR_CODES_BY_KEY;
+/**
+ * tRPC error codes that are considered retryable
+ * With out of the box SSE, the client will reconnect when these errors are encountered
+ */
+declare class TRPCError extends Error {
+  readonly cause?: Error;
+  readonly code: "PARSE_ERROR" | "BAD_REQUEST" | "INTERNAL_SERVER_ERROR" | "NOT_IMPLEMENTED" | "BAD_GATEWAY" | "SERVICE_UNAVAILABLE" | "GATEWAY_TIMEOUT" | "UNAUTHORIZED" | "PAYMENT_REQUIRED" | "FORBIDDEN" | "NOT_FOUND" | "METHOD_NOT_SUPPORTED" | "TIMEOUT" | "CONFLICT" | "PRECONDITION_FAILED" | "PAYLOAD_TOO_LARGE" | "UNSUPPORTED_MEDIA_TYPE" | "UNPROCESSABLE_CONTENT" | "TOO_MANY_REQUESTS" | "CLIENT_CLOSED_REQUEST";
+  constructor(opts: {
+    message?: string;
+    code: TRPC_ERROR_CODE_KEY;
+    cause?: unknown;
+  });
+} //# sourceMappingURL=TRPCError.d.ts.map
+//#endregion
+//#region src/vendor/standard-schema-v1/spec.d.ts
+/**
+ *
+ * @see https://github.com/standard-schema/standard-schema/blob/main/packages/spec/src/index.ts
+ */
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The non-existent issues. */
+    readonly issues?: undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard Schema types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Schema. */
+  type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+  /** Infers the output type of a Standard Schema. */
+  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+} //# sourceMappingURL=spec.d.ts.map
+//#endregion
+//#region src/unstable-core-do-not-import/parser.d.ts
+type ParserZodEsque<TInput, TParsedInput> = {
+  _input: TInput;
+  _output: TParsedInput;
+};
+type ParserValibotEsque<TInput, TParsedInput> = {
+  schema: {
+    _types?: {
+      input: TInput;
+      output: TParsedInput;
+    };
+  };
+};
+type ParserArkTypeEsque<TInput, TParsedInput> = {
+  inferIn: TInput;
+  infer: TParsedInput;
+};
+type ParserStandardSchemaEsque<TInput, TParsedInput> = StandardSchemaV1<TInput, TParsedInput>;
+type ParserMyZodEsque<TInput> = {
+  parse: (input: any) => TInput;
+};
+type ParserSuperstructEsque<TInput> = {
+  create: (input: unknown) => TInput;
+};
+type ParserCustomValidatorEsque<TInput> = (input: unknown) => Promise<TInput> | TInput;
+type ParserYupEsque<TInput> = {
+  validateSync: (input: unknown) => TInput;
+};
+type ParserScaleEsque<TInput> = {
+  assert(value: unknown): asserts value is TInput;
+};
+type ParserWithoutInput<TInput> = ParserCustomValidatorEsque<TInput> | ParserMyZodEsque<TInput> | ParserScaleEsque<TInput> | ParserSuperstructEsque<TInput> | ParserYupEsque<TInput>;
+type ParserWithInputOutput<TInput, TParsedInput> = ParserZodEsque<TInput, TParsedInput> | ParserValibotEsque<TInput, TParsedInput> | ParserArkTypeEsque<TInput, TParsedInput> | ParserStandardSchemaEsque<TInput, TParsedInput>;
+type Parser = ParserWithInputOutput<any, any> | ParserWithoutInput<any>;
+type inferParser<TParser extends Parser> = TParser extends ParserWithInputOutput<infer $TIn, infer $TOut> ? {
+  in: $TIn;
+  out: $TOut;
+} : TParser extends ParserWithoutInput<infer $InOut> ? {
+  in: $InOut;
+  out: $InOut;
+} : never;
+//# sourceMappingURL=parser.d.ts.map
+//#endregion
+//#region src/unstable-core-do-not-import/middleware.d.ts
+/** @internal */
+declare const middlewareMarker: "middlewareMarker" & {
+  __brand: "middlewareMarker";
+};
+type MiddlewareMarker = typeof middlewareMarker;
+interface MiddlewareResultBase {
+  /**
+   * All middlewares should pass through their `next()`'s output.
+   * Requiring this marker makes sure that can't be forgotten at compile-time.
+   */
+  readonly marker: MiddlewareMarker;
+}
+interface MiddlewareOKResult<_TContextOverride> extends MiddlewareResultBase {
+  ok: true;
+  data: unknown;
+}
+interface MiddlewareErrorResult<_TContextOverride> extends MiddlewareResultBase {
+  ok: false;
+  error: TRPCError;
+}
+/**
+ * @internal
+ */
+type MiddlewareResult<_TContextOverride> = MiddlewareErrorResult<_TContextOverride> | MiddlewareOKResult<_TContextOverride>;
+/**
+ * @internal
+ */
+interface MiddlewareBuilder<TContext, TMeta, TContextOverrides, TInputOut> {
+  /**
+   * Create a new builder based on the current middleware builder
+   */
+  unstable_pipe<$ContextOverridesOut>(fn: MiddlewareFunction<TContext, TMeta, TContextOverrides, $ContextOverridesOut, TInputOut> | MiddlewareBuilder<Overwrite<TContext, TContextOverrides>, TMeta, $ContextOverridesOut, TInputOut>): MiddlewareBuilder<TContext, TMeta, Overwrite<TContextOverrides, $ContextOverridesOut>, TInputOut>;
+  /**
+   * List of middlewares within this middleware builder
+   */
+  _middlewares: MiddlewareFunction<TContext, TMeta, TContextOverrides, object, TInputOut>[];
+}
+/**
+ * @internal
+ */
+type MiddlewareFunction<TContext, TMeta, TContextOverridesIn, $ContextOverridesOut, TInputOut> = {
+  (opts: {
+    ctx: Simplify<Overwrite<TContext, TContextOverridesIn>>;
+    type: ProcedureType;
+    path: string;
+    input: TInputOut;
+    getRawInput: GetRawInputFn;
+    meta: TMeta | undefined;
+    signal: AbortSignal | undefined;
+    next: {
+      (): Promise<MiddlewareResult<TContextOverridesIn>>;
+      <$ContextOverride>(opts: {
+        ctx?: $ContextOverride;
+        input?: unknown;
+      }): Promise<MiddlewareResult<$ContextOverride>>;
+      (opts: {
+        getRawInput: GetRawInputFn;
+      }): Promise<MiddlewareResult<TContextOverridesIn>>;
+    };
+  }): Promise<MiddlewareResult<$ContextOverridesOut>>;
+  _type?: string | undefined;
+};
+type AnyMiddlewareFunction = MiddlewareFunction<any, any, any, any, any>;
+//#endregion
+//#region src/unstable-core-do-not-import/stream/tracked.d.ts
+declare const trackedSymbol: unique symbol;
+type TrackedId = string & {
+  __brand: 'TrackedId';
+};
+type TrackedEnvelope<TData> = [TrackedId, TData, typeof trackedSymbol];
+interface TrackedData<TData> {
+  /**
+   * The id of the message to keep track of in case the connection gets lost
+   */
+  id: string;
+  /**
+   * The data field of the message
+   */
+  data: TData;
+}
+/**
+ * Produce a typed server-sent event message
+ * @deprecated use `tracked(id, data)` instead
+ */
+type inferTrackedOutput<TData> = TData extends TrackedEnvelope<infer $Data> ? TrackedData<$Data> : TData; //#endregion
+//#region src/unstable-core-do-not-import/utils.d.ts
+/** @internal */
+type UnsetMarker = 'unsetMarker' & {
+  __brand: 'unsetMarker';
+};
+/**
+ * Ensures there are no duplicate keys when building a procedure.
+ * @internal
+ */
+//#endregion
+//#region src/unstable-core-do-not-import/procedureBuilder.d.ts
+type IntersectIfDefined<TType, TWith> = TType extends UnsetMarker ? TWith : TWith extends UnsetMarker ? TType : Simplify<TType & TWith>;
+type DefaultValue<TValue, TFallback> = TValue extends UnsetMarker ? TFallback : TValue;
+type inferAsyncIterable<TOutput> = TOutput extends AsyncIterable<infer $Yield, infer $Return, infer $Next> ? {
+  yield: $Yield;
+  return: $Return;
+  next: $Next;
+} : never;
+type inferSubscriptionOutput<TOutput> = TOutput extends AsyncIterable<any> ? AsyncIterable<inferTrackedOutput<inferAsyncIterable<TOutput>['yield']>, inferAsyncIterable<TOutput>['return'], inferAsyncIterable<TOutput>['next']> : TypeError<'Subscription output could not be inferred'>;
+type CallerOverride<TContext> = (opts: {
+  args: unknown[];
+  invoke: (opts: ProcedureCallOptions<TContext>) => Promise<unknown>;
+  _def: AnyProcedure['_def'];
+}) => Promise<unknown>;
+type ProcedureBuilderDef<TMeta> = {
+  procedure: true;
+  inputs: Parser[];
+  output?: Parser;
+  meta?: TMeta;
+  resolver?: ProcedureBuilderResolver;
+  middlewares: AnyMiddlewareFunction[];
+  /**
+   * @deprecated use `type` instead
+   */
+  mutation?: boolean;
+  /**
+   * @deprecated use `type` instead
+   */
+  query?: boolean;
+  /**
+   * @deprecated use `type` instead
+   */
+  subscription?: boolean;
+  type?: ProcedureType;
+  caller?: CallerOverride<unknown>;
+};
+/**
+ * Procedure resolver options (what the `.query()`, `.mutation()`, and `.subscription()` functions receive)
+ * @internal
+ */
+interface ProcedureResolverOptions<TContext, _TMeta, TContextOverridesIn, TInputOut> {
+  ctx: Simplify<Overwrite<TContext, TContextOverridesIn>>;
+  input: TInputOut extends UnsetMarker ? undefined : TInputOut;
+  /**
+   * The AbortSignal of the request
+   */
+  signal: AbortSignal | undefined;
+}
+/**
+ * A procedure resolver
+ */
+type ProcedureResolver<TContext, TMeta, TContextOverrides, TInputOut, TOutputParserIn, $Output> = (opts: ProcedureResolverOptions<TContext, TMeta, TContextOverrides, TInputOut>) => MaybePromise<DefaultValue<TOutputParserIn, $Output>>;
+interface ProcedureBuilder<TContext, TMeta, TContextOverrides, TInputIn, TInputOut, TOutputIn, TOutputOut, TCaller extends boolean> {
+  /**
+   * Add an input parser to the procedure.
+   * @see https://trpc.io/docs/v11/server/validators
+   */
+  input<$Parser extends Parser>(schema: TInputOut extends UnsetMarker ? $Parser : inferParser<$Parser>['out'] extends Record<string, unknown> | undefined ? TInputOut extends Record<string, unknown> | undefined ? undefined extends inferParser<$Parser>['out'] ? undefined extends TInputOut ? $Parser : TypeError<'Cannot chain an optional parser to a required parser'> : $Parser : TypeError<'All input parsers did not resolve to an object'> : TypeError<'All input parsers did not resolve to an object'>): ProcedureBuilder<TContext, TMeta, TContextOverrides, IntersectIfDefined<TInputIn, inferParser<$Parser>['in']>, IntersectIfDefined<TInputOut, inferParser<$Parser>['out']>, TOutputIn, TOutputOut, TCaller>;
+  /**
+   * Add an output parser to the procedure.
+   * @see https://trpc.io/docs/v11/server/validators
+   */
+  output<$Parser extends Parser>(schema: $Parser): ProcedureBuilder<TContext, TMeta, TContextOverrides, TInputIn, TInputOut, IntersectIfDefined<TOutputIn, inferParser<$Parser>['in']>, IntersectIfDefined<TOutputOut, inferParser<$Parser>['out']>, TCaller>;
+  /**
+   * Add a meta data to the procedure.
+   * @see https://trpc.io/docs/v11/server/metadata
+   */
+  meta(meta: TMeta): ProcedureBuilder<TContext, TMeta, TContextOverrides, TInputIn, TInputOut, TOutputIn, TOutputOut, TCaller>;
+  /**
+   * Add a middleware to the procedure.
+   * @see https://trpc.io/docs/v11/server/middlewares
+   */
+  use<$ContextOverridesOut>(fn: MiddlewareBuilder<Overwrite<TContext, TContextOverrides>, TMeta, $ContextOverridesOut, TInputOut> | MiddlewareFunction<TContext, TMeta, TContextOverrides, $ContextOverridesOut, TInputOut>): ProcedureBuilder<TContext, TMeta, Overwrite<TContextOverrides, $ContextOverridesOut>, TInputIn, TInputOut, TOutputIn, TOutputOut, TCaller>;
+  /**
+   * @deprecated use {@link concat} instead
+   */
+  unstable_concat<$Context, $Meta, $ContextOverrides, $InputIn, $InputOut, $OutputIn, $OutputOut>(builder: Overwrite<TContext, TContextOverrides> extends $Context ? TMeta extends $Meta ? ProcedureBuilder<$Context, $Meta, $ContextOverrides, $InputIn, $InputOut, $OutputIn, $OutputOut, TCaller> : TypeError<'Meta mismatch'> : TypeError<'Context mismatch'>): ProcedureBuilder<TContext, TMeta, Overwrite<TContextOverrides, $ContextOverrides>, IntersectIfDefined<TInputIn, $InputIn>, IntersectIfDefined<TInputOut, $InputOut>, IntersectIfDefined<TOutputIn, $OutputIn>, IntersectIfDefined<TOutputOut, $OutputOut>, TCaller>;
+  /**
+   * Combine two procedure builders
+   */
+  concat<$Context, $Meta, $ContextOverrides, $InputIn, $InputOut, $OutputIn, $OutputOut>(builder: Overwrite<TContext, TContextOverrides> extends $Context ? TMeta extends $Meta ? ProcedureBuilder<$Context, $Meta, $ContextOverrides, $InputIn, $InputOut, $OutputIn, $OutputOut, TCaller> : TypeError<'Meta mismatch'> : TypeError<'Context mismatch'>): ProcedureBuilder<TContext, TMeta, Overwrite<TContextOverrides, $ContextOverrides>, IntersectIfDefined<TInputIn, $InputIn>, IntersectIfDefined<TInputOut, $InputOut>, IntersectIfDefined<TOutputIn, $OutputIn>, IntersectIfDefined<TOutputOut, $OutputOut>, TCaller>;
+  /**
+   * Query procedure
+   * @see https://trpc.io/docs/v11/concepts#vocabulary
+   */
+  query<$Output>(resolver: ProcedureResolver<TContext, TMeta, TContextOverrides, TInputOut, TOutputIn, $Output>): TCaller extends true ? (input: DefaultValue<TInputIn, void>) => Promise<DefaultValue<TOutputOut, $Output>> : QueryProcedure<{
+    input: DefaultValue<TInputIn, void>;
+    output: DefaultValue<TOutputOut, $Output>;
+    meta: TMeta;
+  }>;
+  /**
+   * Mutation procedure
+   * @see https://trpc.io/docs/v11/concepts#vocabulary
+   */
+  mutation<$Output>(resolver: ProcedureResolver<TContext, TMeta, TContextOverrides, TInputOut, TOutputIn, $Output>): TCaller extends true ? (input: DefaultValue<TInputIn, void>) => Promise<DefaultValue<TOutputOut, $Output>> : MutationProcedure<{
+    input: DefaultValue<TInputIn, void>;
+    output: DefaultValue<TOutputOut, $Output>;
+    meta: TMeta;
+  }>;
+  /**
+   * Subscription procedure
+   * @see https://trpc.io/docs/v11/server/subscriptions
+   */
+  subscription<$Output extends AsyncIterable<any, void, any>>(resolver: ProcedureResolver<TContext, TMeta, TContextOverrides, TInputOut, TOutputIn, $Output>): TCaller extends true ? TypeError<'Not implemented'> : SubscriptionProcedure<{
+    input: DefaultValue<TInputIn, void>;
+    output: inferSubscriptionOutput<DefaultValue<TOutputOut, $Output>>;
+    meta: TMeta;
+  }>;
+  /**
+   * @deprecated Using subscriptions with an observable is deprecated. Use an async generator instead.
+   * This feature will be removed in v12 of tRPC.
+   * @see https://trpc.io/docs/v11/server/subscriptions
+   */
+  subscription<$Output extends Observable<any, any>>(resolver: ProcedureResolver<TContext, TMeta, TContextOverrides, TInputOut, TOutputIn, $Output>): TCaller extends true ? TypeError<'Not implemented'> : LegacyObservableSubscriptionProcedure<{
+    input: DefaultValue<TInputIn, void>;
+    output: inferObservableValue<DefaultValue<TOutputOut, $Output>>;
+    meta: TMeta;
+  }>;
+  /**
+   * Overrides the way a procedure is invoked
+   * Do not use this unless you know what you're doing - this is an experimental API
+   */
+  experimental_caller(caller: CallerOverride<TContext>): ProcedureBuilder<TContext, TMeta, TContextOverrides, TInputIn, TInputOut, TOutputIn, TOutputOut, true>;
+  /**
+   * @internal
+   */
+  _def: ProcedureBuilderDef<TMeta>;
+}
+type ProcedureBuilderResolver = (opts: ProcedureResolverOptions<any, any, any, any>) => Promise<unknown>;
+/**
+ * @internal
+ */
+interface ProcedureCallOptions<TContext> {
+  ctx: TContext;
+  getRawInput: GetRawInputFn;
+  input?: unknown;
+  path: string;
+  type: ProcedureType;
+  signal: AbortSignal | undefined;
+} //#endregion
+//#region src/unstable-core-do-not-import/procedure.d.ts
+declare const procedureTypes: readonly ["query", "mutation", "subscription"];
+/**
+ * @public
+ */
+type ProcedureType = (typeof procedureTypes)[number];
+interface BuiltProcedureDef {
+  meta: unknown;
+  input: unknown;
+  output: unknown;
+}
+/**
+ *
+ * @internal
+ */
+interface Procedure<TType extends ProcedureType, TDef extends BuiltProcedureDef> {
+  _def: {
+    /**
+     * These are just types, they can't be used at runtime
+     * @internal
+     */
+    $types: {
+      input: TDef['input'];
+      output: TDef['output'];
+    };
+    procedure: true;
+    type: TType;
+    /**
+     * @internal
+     * Meta is not inferrable on individual procedures, only on the router
+     */
+    meta: unknown;
+    experimental_caller: boolean;
+    /**
+     * The input parsers for the procedure
+     */
+    inputs: Parser[];
+  };
+  meta: TDef['meta'];
+  /**
+   * @internal
+   */
+  (opts: ProcedureCallOptions<unknown>): Promise<TDef['output']>;
+}
+interface QueryProcedure<TDef extends BuiltProcedureDef> extends Procedure<'query', TDef> {}
+interface MutationProcedure<TDef extends BuiltProcedureDef> extends Procedure<'mutation', TDef> {}
+interface SubscriptionProcedure<TDef extends BuiltProcedureDef> extends Procedure<'subscription', TDef> {}
+/**
+ * @deprecated
+ */
+interface LegacyObservableSubscriptionProcedure<TDef extends BuiltProcedureDef> extends SubscriptionProcedure<TDef> {
+  _observable: true;
+}
+type AnyQueryProcedure = QueryProcedure<any>;
+type AnyMutationProcedure = MutationProcedure<any>;
+type AnySubscriptionProcedure = SubscriptionProcedure<any> | LegacyObservableSubscriptionProcedure<any>;
+type AnyProcedure = AnyQueryProcedure | AnyMutationProcedure | AnySubscriptionProcedure;
+type inferProcedureInput<TProcedure extends AnyProcedure> = undefined extends inferProcedureParams<TProcedure>['$types']['input'] ? void | inferProcedureParams<TProcedure>['$types']['input'] : inferProcedureParams<TProcedure>['$types']['input'];
+type inferProcedureParams<TProcedure> = TProcedure extends AnyProcedure ? TProcedure['_def'] : never;
+type inferProcedureOutput<TProcedure> = inferProcedureParams<TProcedure>['$types']['output'];
+/**
+ * @internal
+ */
+interface ErrorHandlerOptions<TContext> {
+  error: TRPCError;
+  type: ProcedureType | 'unknown';
+  path: string | undefined;
+  input: unknown;
+  ctx: TContext | undefined;
+} //#endregion
+//#region src/unstable-core-do-not-import/http/types.d.ts
+/**
+ * @deprecated use `Headers` instead, this will be removed in v12
+ */
+//#endregion
+//#region src/unstable-core-do-not-import/rpc/envelopes.d.ts
+/**
+ * Error response
+ */
+interface TRPCErrorShape<TData extends object = object> {
+  code: TRPC_ERROR_CODE_NUMBER;
+  message: string;
+  data: TData;
+}
+/**
+ * JSON-RPC 2.0 Specification
+ */
+//# sourceMappingURL=envelopes.d.ts.map
+//#endregion
+//#region src/unstable-core-do-not-import/transformer.d.ts
+/**
+ * @public
+ */
+interface DataTransformer {
+  serialize: (object: any) => any;
+  deserialize: (object: any) => any;
+}
+interface InputDataTransformer extends DataTransformer {
+  /**
+   * This function runs **on the client** before sending the data to the server.
+   */
+  serialize: (object: any) => any;
+  /**
+   * This function runs **on the server** to transform the data before it is passed to the resolver
+   */
+  deserialize: (object: any) => any;
+}
+interface OutputDataTransformer extends DataTransformer {
+  /**
+   * This function runs **on the server** before sending the data to the client.
+   */
+  serialize: (object: any) => any;
+  /**
+   * This function runs **only on the client** to transform the data sent from the server.
+   */
+  deserialize: (object: any) => any;
+}
+/**
+ * @public
+ */
+interface CombinedDataTransformer {
+  /**
+   * Specify how the data sent from the client to the server should be transformed.
+   */
+  input: InputDataTransformer;
+  /**
+   * Specify how the data sent from the server to the client should be transformed.
+   */
+  output: OutputDataTransformer;
+}
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+type DataTransformerOptions = CombinedDataTransformer | DataTransformer;
+/**
+ * @internal
+ */
+//# sourceMappingURL=parseTRPCMessage.d.ts.map
+//#endregion
+//#region src/unstable-core-do-not-import/error/formatter.d.ts
+/**
+ * @internal
+ */
+type ErrorFormatter<TContext, TShape extends TRPCErrorShape> = (opts: {
+  error: TRPCError;
+  type: ProcedureType | 'unknown';
+  path: string | undefined;
+  input: unknown;
+  ctx: TContext | undefined;
+  shape: DefaultErrorShape;
+}) => TShape;
+/**
+ * @internal
+ */
+type DefaultErrorData = {
+  code: TRPC_ERROR_CODE_KEY;
+  httpStatus: number;
+  /**
+   * Path to the procedure that threw the error
+   */
+  path?: string;
+  /**
+   * Stack trace of the error (only in development)
+   */
+  stack?: string;
+};
+/**
+ * @internal
+ */
+interface DefaultErrorShape extends TRPCErrorShape<DefaultErrorData> {
+  message: string;
+  code: TRPC_ERROR_CODE_NUMBER;
+}
+type Serialize$2 = (value: any) => any;
+type PathArray = readonly (string | number)[];
+type ProducerOnError = (opts: {
+  error: unknown;
+  path: PathArray;
+}) => void;
+interface JSONLProducerOptions {
+  serialize?: Serialize$2;
+  data: Record<string, unknown> | unknown[];
+  onError?: ProducerOnError;
+  formatError?: (opts: {
+    error: unknown;
+    path: PathArray;
+  }) => unknown;
+  maxDepth?: number;
+  /**
+   * Interval in milliseconds to send a ping to the client to keep the connection alive
+   * This will be sent as a whitespace character
+   * @default undefined
+   */
+  pingMs?: number;
+}
+/**
+ * JSON Lines stream producer
+ * @see https://jsonlines.org/
+ */
+//# sourceMappingURL=sse.types.d.ts.map
+//#endregion
+//#region src/unstable-core-do-not-import/stream/sse.d.ts
+type Serialize$1 = (value: any) => any;
+/**
+ * @internal
+ */
+interface SSEPingOptions {
+  /**
+   * Enable ping comments sent from the server
+   * @default false
+   */
+  enabled: boolean;
+  /**
+   * Interval in milliseconds
+   * @default 1000
+   */
+  intervalMs?: number;
+}
+interface SSEClientOptions {
+  /**
+   * Timeout and reconnect after inactivity in milliseconds
+   * @default undefined
+   */
+  reconnectAfterInactivityMs?: number;
+}
+interface SSEStreamProducerOptions<TValue = unknown> {
+  serialize?: Serialize$1;
+  data: AsyncIterable<TValue>;
+  maxDepth?: number;
+  ping?: SSEPingOptions;
+  /**
+   * Maximum duration in milliseconds for the request before ending the stream
+   * @default undefined
+   */
+  maxDurationMs?: number;
+  /**
+   * End the request immediately after data is sent
+   * Only useful for serverless runtimes that do not support streaming responses
+   * @default false
+   */
+  emitAndEndImmediately?: boolean;
+  formatError?: (opts: {
+    error: unknown;
+  }) => unknown;
+  /**
+   * Client-specific options - these will be sent to the client as part of the first message
+   * @default {}
+   */
+  client?: SSEClientOptions;
+}
+/**
+ *
+ * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
+ */
+//#endregion
+//#region src/unstable-core-do-not-import/rootConfig.d.ts
+/**
+ * The initial generics that are used in the init function
+ * @internal
+ */
+interface RootTypes {
+  ctx: object;
+  meta: object;
+  errorShape: DefaultErrorShape;
+  transformer: boolean;
+}
+/**
+ * The default check to see if we're in a server
+ */
+/**
+ * The tRPC root config
+ * @internal
+ */
+interface RootConfig<TTypes extends RootTypes> {
+  /**
+   * The types that are used in the config
+   * @internal
+   */
+  $types: TTypes;
+  /**
+   * Use a data transformer
+   * @see https://trpc.io/docs/v11/data-transformers
+   */
+  transformer: CombinedDataTransformer;
+  /**
+   * Use custom error formatting
+   * @see https://trpc.io/docs/v11/error-formatting
+   */
+  errorFormatter: ErrorFormatter<TTypes['ctx'], TTypes['errorShape']>;
+  /**
+   * Allow `@trpc/server` to run in non-server environments
+   * @warning **Use with caution**, this should likely mainly be used within testing.
+   * @default false
+   */
+  allowOutsideOfServer: boolean;
+  /**
+   * Is this a server environment?
+   * @warning **Use with caution**, this should likely mainly be used within testing.
+   * @default typeof window === 'undefined' || 'Deno' in window || process.env.NODE_ENV === 'test'
+   */
+  isServer: boolean;
+  /**
+   * Is this development?
+   * Will be used to decide if the API should return stack traces
+   * @default process.env.NODE_ENV !== 'production'
+   */
+  isDev: boolean;
+  defaultMeta?: TTypes['meta'] extends object ? TTypes['meta'] : never;
+  /**
+   * Options for server-sent events (SSE) subscriptions
+   * @see https://trpc.io/docs/client/links/httpSubscriptionLink
+   */
+  sse?: {
+    /**
+     * Enable server-sent events (SSE) subscriptions
+     * @default true
+     */
+    enabled?: boolean;
+  } & Pick<SSEStreamProducerOptions, 'ping' | 'emitAndEndImmediately' | 'maxDurationMs' | 'client'>;
+  /**
+   * Options for batch stream
+   * @see https://trpc.io/docs/client/links/httpBatchStreamLink
+   */
+  jsonl?: Pick<JSONLProducerOptions, 'pingMs'>;
+  experimental?: {};
+}
+/**
+ * @internal
+ */
+type CreateRootTypes<TGenerics extends RootTypes> = TGenerics;
+type AnyRootTypes = CreateRootTypes<{
+  ctx: any;
+  meta: any;
+  errorShape: any;
+  transformer: any;
+}>;
+//#endregion
+//#region src/unstable-core-do-not-import/router.d.ts
+interface RouterRecord {
+  [key: string]: AnyProcedure | RouterRecord;
+}
+type DecorateProcedure<TProcedure extends AnyProcedure> = (input: inferProcedureInput<TProcedure>) => Promise<TProcedure['_def']['type'] extends 'subscription' ? TProcedure extends LegacyObservableSubscriptionProcedure<any> ? Observable<inferProcedureOutput<TProcedure>, TRPCError> : inferProcedureOutput<TProcedure> : inferProcedureOutput<TProcedure>>;
+/**
+ * @internal
+ */
+type DecorateRouterRecord<TRecord extends RouterRecord> = { [TKey in keyof TRecord]: TRecord[TKey] extends infer $Value ? $Value extends AnyProcedure ? DecorateProcedure<$Value> : $Value extends RouterRecord ? DecorateRouterRecord<$Value> : never : never };
+/**
+ * @internal
+ */
+type RouterCallerErrorHandler<TContext> = (opts: ErrorHandlerOptions<TContext>) => void;
+/**
+ * @internal
+ */
+type RouterCaller<TRoot extends AnyRootTypes, TRecord extends RouterRecord> = (
+/**
+ * @note
+ * If passing a function, we recommend it's a cached function
+ * e.g. wrapped in `React.cache` to avoid unnecessary computations
+ */
+
+ctx: TRoot['ctx'] | (() => MaybePromise<TRoot['ctx']>), options?: {
+  onError?: RouterCallerErrorHandler<TRoot['ctx']>;
+  signal?: AbortSignal;
+}) => DecorateRouterRecord<TRecord>;
+declare const lazySymbol: unique symbol;
+type Lazy<TAny> = (() => Promise<TAny>) & {
+  [lazySymbol]: true;
+};
+type LazyLoader<TAny> = {
+  load: () => Promise<void>;
+  ref: Lazy<TAny>;
+};
+/**
+ * Lazy load a router
+ * @see https://trpc.io/docs/server/merging-routers#lazy-load
+ */
+/**
+ * @internal
+ */
+interface RouterDef<TRoot extends AnyRootTypes, TRecord extends RouterRecord> {
+  _config: RootConfig<TRoot>;
+  router: true;
+  procedure?: never;
+  procedures: TRecord;
+  record: TRecord;
+  lazy: Record<string, LazyLoader<AnyRouter>>;
+}
+interface Router<TRoot extends AnyRootTypes, TRecord extends RouterRecord> {
+  _def: RouterDef<TRoot, TRecord>;
+  /**
+   * @see https://trpc.io/docs/v11/server/server-side-calls
+   */
+  createCaller: RouterCaller<TRoot, TRecord>;
+}
+type BuiltRouter<TRoot extends AnyRootTypes, TRecord extends RouterRecord> = Router<TRoot, TRecord> & TRecord;
+interface RouterBuilder<TRoot extends AnyRootTypes> {
+  <TIn extends CreateRouterOptions>(_: TIn): BuiltRouter<TRoot, DecorateCreateRouterOptions<TIn>>;
+}
+type AnyRouter = Router<any, any>;
+/** @internal */
+type CreateRouterOptions = {
+  [key: string]: AnyProcedure | AnyRouter | CreateRouterOptions | Lazy<AnyRouter>;
+};
+/** @internal */
+type DecorateCreateRouterOptions<TRouterOptions extends CreateRouterOptions> = { [K in keyof TRouterOptions]: TRouterOptions[K] extends infer $Value ? $Value extends AnyProcedure ? $Value : $Value extends Router<any, infer TRecord> ? TRecord : $Value extends Lazy<Router<any, infer TRecord>> ? TRecord : $Value extends CreateRouterOptions ? DecorateCreateRouterOptions<$Value> : never : never };
+/**
+ * @internal
+ */
+interface RouterCallerFactory<TRoot extends AnyRootTypes> {
+  <TRecord extends RouterRecord>(router: Pick<Router<TRoot, TRecord>, '_def'>): RouterCaller<TRoot, TRecord>;
+}
+/** @internal */
+type MergeRouters<TRouters extends AnyRouter[], TRoot extends AnyRootTypes = TRouters[0]['_def']['_config']['$types'], TRecord extends RouterRecord = {}> = TRouters extends [infer Head extends AnyRouter, ...infer Tail extends AnyRouter[]] ? MergeRouters<Tail, TRoot, Head['_def']['record'] & TRecord> : BuiltRouter<TRoot, TRecord>;
+//#endregion
+//#region src/unstable-core-do-not-import/initTRPC.d.ts
+type inferErrorFormatterShape<TType> = TType extends ErrorFormatter<any, infer TShape> ? TShape : DefaultErrorShape;
+/** @internal */
+interface RuntimeConfigOptions<TContext extends object, TMeta extends object> extends Partial<Omit<RootConfig<{
+  ctx: TContext;
+  meta: TMeta;
+  errorShape: any;
+  transformer: any;
+}>, '$types' | 'transformer'>> {
+  /**
+   * Use a data transformer
+   * @see https://trpc.io/docs/v11/data-transformers
+   */
+  transformer?: DataTransformerOptions;
+}
+interface TRPCRootObject<TContext extends object, TMeta extends object, TOptions extends RuntimeConfigOptions<TContext, TMeta>, $Root extends AnyRootTypes = {
+  ctx: TContext;
+  meta: TMeta;
+  errorShape: undefined extends TOptions['errorFormatter'] ? DefaultErrorShape : inferErrorFormatterShape<TOptions['errorFormatter']>;
+  transformer: undefined extends TOptions['transformer'] ? false : true;
+}> {
+  /**
+   * Your router config
+   * @internal
+   */
+  _config: RootConfig<$Root>;
+  /**
+   * Builder object for creating procedures
+   * @see https://trpc.io/docs/v11/server/procedures
+   */
+  procedure: ProcedureBuilder<TContext, TMeta, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false>;
+  /**
+   * Create reusable middlewares
+   * @see https://trpc.io/docs/v11/server/middlewares
+   */
+  middleware: <$ContextOverrides>(fn: MiddlewareFunction<TContext, TMeta, object, $ContextOverrides, unknown>) => MiddlewareBuilder<TContext, TMeta, $ContextOverrides, unknown>;
+  /**
+   * Create a router
+   * @see https://trpc.io/docs/v11/server/routers
+   */
+  router: RouterBuilder<$Root>;
+  /**
+   * Merge Routers
+   * @see https://trpc.io/docs/v11/server/merging-routers
+   */
+  mergeRouters: <TRouters extends AnyRouter[]>(...routerList: [...TRouters]) => MergeRouters<TRouters>;
+  /**
+   * Create a server-side caller for a router
+   * @see https://trpc.io/docs/v11/server/server-side-calls
+   */
+  createCallerFactory: RouterCallerFactory<$Root>;
+}
+//#endregion
+export { BuiltRouter, DecorateCreateRouterOptions, DefaultErrorShape, MutationProcedure, QueryProcedure, TRPCError, TRPCRootObject, TRPC_ERROR_CODE_KEY };
+//# sourceMappingURL=unstable-core-do-not-import.d-ClFRzVsT.d.ts.map