@trpc/server 10.45.1-canary.2 → 10.45.1-canary.20

package/src/adapters/node-http/content-type/form-data/memoryUploadHandler.ts

@@ -8,7 +8,8 @@
 /**
  * @see https://github.com/remix-run/remix/blob/0bcb4a304dd2f08f6032c3bf0c3aa7eb5b976901/packages/remix-server-runtime/upload/memoryUploadHandler.ts
  */
-import { MaxPartSizeExceededError, UploadHandler } from './uploadHandler';
+import type { UploadHandler } from './uploadHandler';
+import { MaxPartSizeExceededError } from './uploadHandler';
 
 export type MemoryUploadHandlerFilterArgs = {
   filename?: string;

package/src/adapters/node-http/content-type/form-data/streamSlice.ts

@@ -1,4 +1,5 @@
-import { Transform, TransformCallback } from 'node:stream';
+import type { TransformCallback } from 'node:stream';
+import { Transform } from 'node:stream';
 
 class SliceStream extends Transform {
   private indexOffset = 0;

package/src/adapters/node-http/content-type/form-data/uploadHandler.ts

@@ -1,4 +1,4 @@
-import { NodeOnDiskFile } from './fileUploadHandler';
+import type { NodeOnDiskFile } from './fileUploadHandler';
 
 /**
  * @see https://github.com/remix-run/remix/blob/0bcb4a304dd2f08f6032c3bf0c3aa7eb5b976901/packages/remix-server-runtime/formData.ts

package/src/adapters/node-http/content-type/json/getPostBody.ts

@@ -1,6 +1,6 @@
 import { TRPCError } from '../../../../error/TRPCError';
-import { BodyResult } from '../../../../http/contentType';
-import { NodeHTTPRequest } from '../../types';
+import type { BodyResult } from '../../../../http/contentType';
+import type { NodeHTTPRequest } from '../../types';
 
 export async function getPostBody(opts: {
   req: NodeHTTPRequest;

package/src/adapters/node-http/internals/contentType.ts

@@ -1,6 +1,6 @@
-import { AnyRouter } from '../../../core';
-import { BaseContentTypeHandler } from '../../../http/contentType';
-import {
+import type { AnyRouter } from '../../../core';
+import type { BaseContentTypeHandler } from '../../../http/contentType';
+import type {
   NodeHTTPRequest,
   NodeHTTPRequestHandlerOptions,
   NodeHTTPResponse,

package/src/adapters/node-http/nodeHTTPRequestHandler.ts

@@ -1,12 +1,13 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { AnyRouter } from '../../core';
-import { inferRouterContext } from '../../core/types';
-import { getBatchStreamFormatter, HTTPRequest } from '../../http';
-import { HTTPResponse, ResponseChunk } from '../../http/internals/types';
+import type { AnyRouter } from '../../core';
+import type { inferRouterContext } from '../../core/types';
+import type { HTTPRequest } from '../../http';
+import { getBatchStreamFormatter } from '../../http';
+import type { HTTPResponse, ResponseChunk } from '../../http/internals/types';
 import { resolveHTTPResponse } from '../../http/resolveHTTPResponse';
 import { nodeHTTPJSONContentTypeHandler } from './content-type/json';
-import { NodeHTTPContentTypeHandler } from './internals/contentType';
-import {
+import type { NodeHTTPContentTypeHandler } from './internals/contentType';
+import type {
   NodeHTTPRequest,
   NodeHTTPRequestHandlerOptions,
   NodeHTTPResponse,

package/src/adapters/node-http/types.ts

@@ -1,8 +1,8 @@
-import { IncomingMessage, ServerResponse } from 'http';
-import { AnyRouter, inferRouterContext } from '../../core';
-import { HTTPBaseHandlerOptions } from '../../http';
-import { MaybePromise } from '../../types';
-import { NodeHTTPContentTypeHandler } from './internals/contentType';
+import type { IncomingMessage, ServerResponse } from 'http';
+import type { AnyRouter, inferRouterContext } from '../../core';
+import type { HTTPBaseHandlerOptions } from '../../http';
+import type { MaybePromise } from '../../types';
+import type { NodeHTTPContentTypeHandler } from './internals/contentType';
 
 interface ParsedQs {
   [key: string]: ParsedQs | ParsedQs[] | string[] | string | undefined;

package/src/adapters/standalone.ts

@@ -1,11 +1,11 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import http from 'http';
-import { AnyRouter } from '../core';
-import {
+import type { AnyRouter } from '../core';
+import type {
   NodeHTTPCreateContextFnOptions,
   NodeHTTPHandlerOptions,
-  nodeHTTPRequestHandler,
 } from './node-http';
+import { nodeHTTPRequestHandler } from './node-http';
 
 export type CreateHTTPHandlerOptions<TRouter extends AnyRouter> =
   NodeHTTPHandlerOptions<TRouter, http.IncomingMessage, http.ServerResponse>;

package/src/adapters/ws.ts

@@ -1,19 +1,21 @@
-import { IncomingMessage } from 'http';
-import { WebSocket, WebSocketServer } from 'ws';
-import { AnyRouter, callProcedure, inferRouterContext } from '../core';
+import type { IncomingMessage } from 'http';
+import type { WebSocket, WebSocketServer } from 'ws';
+import type { AnyRouter, inferRouterContext } from '../core';
+import { callProcedure } from '../core';
 import { getTRPCErrorFromUnknown, TRPCError } from '../error/TRPCError';
-import { BaseHandlerOptions } from '../internals/types';
-import { isObservable, Unsubscribable } from '../observable';
-import {
+import type { BaseHandlerOptions } from '../internals/types';
+import type { Unsubscribable } from '../observable';
+import { isObservable } from '../observable';
+import type {
   JSONRPC2,
-  parseTRPCMessage,
   TRPCClientOutgoingMessage,
   TRPCReconnectNotification,
   TRPCResponseMessage,
 } from '../rpc';
+import { parseTRPCMessage } from '../rpc';
 import { getErrorShape } from '../shared/getErrorShape';
 import { transformTRPCResponse } from '../shared/transformTRPCResponse';
-import {
+import type {
   NodeHTTPCreateContextFnOptions,
   NodeHTTPCreateContextOption,
 } from './node-http';

package/src/core/initTRPC.ts

@@ -1,27 +1,30 @@
-import {
+import type {
   DefaultErrorShape,
-  defaultFormatter,
   ErrorFormatter,
   ErrorFormatterShape,
 } from '../error/formatter';
+import { defaultFormatter } from '../error/formatter';
 import { createFlatProxy } from '../shared/createProxy';
-import {
+import type {
   DataTransformerOptions,
   DefaultDataTransformer,
-  defaultTransformer,
-  getDataTransformer,
 } from '../transformer';
-import { Unwrap } from '../types';
-import {
+import { defaultTransformer, getDataTransformer } from '../transformer';
+import type { Unwrap } from '../types';
+import type {
   CreateRootConfigTypes,
-  isServerDefault,
   RootConfig,
   RootConfigTypes,
   RuntimeConfig,
 } from './internals/config';
+import { isServerDefault } from './internals/config';
 import { mergeRouters } from './internals/mergeRouters';
 import { createBuilder } from './internals/procedureBuilder';
-import { Overwrite, PickFirstDefined, ValidateShape } from './internals/utils';
+import type {
+  Overwrite,
+  PickFirstDefined,
+  ValidateShape,
+} from './internals/utils';
 import { createMiddlewareFactory } from './middleware';
 import { createCallerFactory, createRouterFactory } from './router';
 

package/src/core/internals/config.ts

@@ -1,4 +1,4 @@
-import { ErrorFormatter } from '../../error/formatter';
+import type { ErrorFormatter } from '../../error/formatter';
 import type { TRPCErrorShape } from '../../rpc';
 
 /**

package/src/core/internals/getParseFn.ts

@@ -1,4 +1,4 @@
-import { Parser } from '../parser';
+import type { Parser } from '../parser';
 
 export type ParseFn<TType> = (value: unknown) => Promise<TType> | TType;
 

package/src/core/internals/mergeRouters.ts

@@ -1,12 +1,8 @@
 import { defaultFormatter } from '../../error/formatter';
-import { CombinedDataTransformer, defaultTransformer } from '../../transformer';
-import {
-  AnyRouter,
-  AnyRouterDef,
-  createRouterFactory,
-  Router,
-  RouterDef,
-} from '../router';
+import type { CombinedDataTransformer } from '../../transformer';
+import { defaultTransformer } from '../../transformer';
+import type { AnyRouter, AnyRouterDef, Router, RouterDef } from '../router';
+import { createRouterFactory } from '../router';
 import { mergeWithoutOverrides } from './mergeWithoutOverrides';
 
 /**

package/src/core/internals/procedureBuilder.ts

@@ -1,14 +1,13 @@
 import { getTRPCErrorFromUnknown, TRPCError } from '../../error/TRPCError';
-import { MaybePromise, Simplify } from '../../types';
-import {
-  createInputMiddleware,
-  createOutputMiddleware,
+import type { MaybePromise, Simplify } from '../../types';
+import type {
   MiddlewareBuilder,
   MiddlewareFunction,
   MiddlewareResult,
 } from '../middleware';
-import { inferParser, Parser } from '../parser';
-import {
+import { createInputMiddleware, createOutputMiddleware } from '../middleware';
+import type { inferParser, Parser } from '../parser';
+import type {
   AnyMutationProcedure,
   AnyProcedure,
   AnyQueryProcedure,
@@ -16,18 +15,18 @@ import {
   Procedure,
   ProcedureParams,
 } from '../procedure';
-import { ProcedureType } from '../types';
-import { AnyRootConfig } from './config';
+import type { ProcedureType } from '../types';
+import type { AnyRootConfig } from './config';
 import { getParseFn } from './getParseFn';
 import { mergeWithoutOverrides } from './mergeWithoutOverrides';
-import {
+import type {
   DefaultValue,
-  middlewareMarker,
   Overwrite,
   OverwriteKnown,
   ResolveOptions,
   UnsetMarker,
 } from './utils';
+import { middlewareMarker } from './utils';
 
 type CreateProcedureReturnInput<
   TPrev extends ProcedureParams,

package/src/core/internals/utils.ts

@@ -1,5 +1,5 @@
-import { Simplify, WithoutIndexSignature } from '../../types';
-import { ProcedureParams } from '../procedure';
+import type { Simplify, WithoutIndexSignature } from '../../types';
+import type { ProcedureParams } from '../procedure';
 
 /**
  * @internal

package/src/core/middleware.ts

@@ -1,16 +1,16 @@
 import { TRPCError } from '../error/TRPCError';
-import { Simplify } from '../types';
-import { AnyRootConfig, RootConfig } from './internals/config';
-import { ParseFn } from './internals/getParseFn';
-import { ProcedureBuilderMiddleware } from './internals/procedureBuilder';
-import {
+import type { Simplify } from '../types';
+import type { AnyRootConfig, RootConfig } from './internals/config';
+import type { ParseFn } from './internals/getParseFn';
+import type { ProcedureBuilderMiddleware } from './internals/procedureBuilder';
+import type {
   DefaultValue,
   MiddlewareMarker,
   Overwrite,
   UnsetMarker,
 } from './internals/utils';
-import { ProcedureParams } from './procedure';
-import { ProcedureType } from './types';
+import type { ProcedureParams } from './procedure';
+import type { ProcedureType } from './types';
 
 /**
  * @internal

package/src/core/procedure.ts

@@ -1,10 +1,10 @@
-import { AnyRootConfig } from './internals/config';
-import {
+import type { AnyRootConfig } from './internals/config';
+import type {
   ProcedureBuilderDef,
   ProcedureCallOptions,
 } from './internals/procedureBuilder';
-import { UnsetMarker } from './internals/utils';
-import { ProcedureType } from './types';
+import type { UnsetMarker } from './internals/utils';
+import type { ProcedureType } from './types';
 
 type ClientContext = Record<string, unknown>;
 

package/src/core/router.ts

@@ -1,25 +1,26 @@
-import { DefaultErrorShape, defaultFormatter } from '../error/formatter';
+import type { DefaultErrorShape } from '../error/formatter';
+import { defaultFormatter } from '../error/formatter';
 import { TRPCError } from '../error/TRPCError';
 import { getHTTPStatusCodeFromError } from '../http/getHTTPStatusCode';
 import { TRPC_ERROR_CODES_BY_KEY } from '../rpc';
 import { createRecursiveProxy } from '../shared/createProxy';
 import { defaultTransformer } from '../transformer';
-import { AnyRootConfig } from './internals/config';
+import type { AnyRootConfig } from './internals/config';
 import { omitPrototype } from './internals/omitPrototype';
-import { ProcedureCallOptions } from './internals/procedureBuilder';
-import {
+import type { ProcedureCallOptions } from './internals/procedureBuilder';
+import type {
   AnyMutationProcedure,
   AnyProcedure,
   AnyQueryProcedure,
   AnySubscriptionProcedure,
   ProcedureArgs,
 } from './procedure';
-import {
+import type {
   inferHandlerInput,
   inferProcedureOutput,
   ProcedureType,
-  procedureTypes,
 } from './types';
+import { procedureTypes } from './types';
 
 /** @internal **/
 export type ProcedureRecord = Record<string, AnyProcedure>;

package/src/core/types.ts

@@ -1,7 +1,7 @@
-import { inferObservableValue } from '../observable';
-import { inferTransformedProcedureOutput } from '../shared/jsonify';
-import { AnyProcedure, ProcedureArgs } from './procedure';
-import { AnyRouter, AnyRouterDef, Router } from './router';
+import type { inferObservableValue } from '../observable';
+import type { inferTransformedProcedureOutput } from '../shared/jsonify';
+import type { AnyProcedure, ProcedureArgs } from './procedure';
+import type { AnyRouter, AnyRouterDef, Router } from './router';
 
 export type inferRouterDef<TRouter extends AnyRouter> = TRouter extends Router<
   infer TParams

package/src/deprecated/internals/middlewares.ts

@@ -1,5 +1,5 @@
-import { TRPCError } from '../../error/TRPCError';
-import { ProcedureType } from '../router';
+import type { TRPCError } from '../../error/TRPCError';
+import type { ProcedureType } from '../router';
 
 /**
  * @deprecated

package/src/deprecated/internals/procedure.ts

@@ -1,11 +1,8 @@
 import { getTRPCErrorFromUnknown, TRPCError } from '../../error/TRPCError';
-import { InferLast } from '../../types';
-import { ProcedureType } from '../router';
-import {
-  MiddlewareFunction,
-  middlewareMarker,
-  MiddlewareResult,
-} from './middlewares';
+import type { InferLast } from '../../types';
+import type { ProcedureType } from '../router';
+import type { MiddlewareFunction, MiddlewareResult } from './middlewares';
+import { middlewareMarker } from './middlewares';
 
 export type ProcedureParserZodEsque<TInput, TOutput> = {
   _input: TInput;

package/src/deprecated/interop.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/ban-types */
-import { ProcedureParams, ProcedureType } from '..';
-import { AnyRootConfig, RootConfig } from '../core/internals/config';
+import type { ProcedureParams, ProcedureType } from '..';
+import type { AnyRootConfig, RootConfig } from '../core/internals/config';
 import { getParseFnOrPassThrough } from '../core/internals/getParseFn';
 import { mergeWithoutOverrides } from '../core/internals/mergeWithoutOverrides';
 import { createBuilder } from '../core/internals/procedureBuilder';
@@ -8,21 +8,21 @@ import {
   createInputMiddleware,
   createOutputMiddleware,
 } from '../core/middleware';
-import { Procedure } from '../core/procedure';
-import {
-  createRouterFactory,
+import type { Procedure } from '../core/procedure';
+import type {
   ProcedureRecord as NewProcedureRecord,
   Router as NewRouter,
   RouterDef,
 } from '../core/router';
-import {
+import { createRouterFactory } from '../core/router';
+import type {
   AnyRouter as AnyOldRouter,
   Router as OldRouter,
 } from '../deprecated/router';
-import { TRPCErrorShape } from '../rpc';
-import { CombinedDataTransformer } from '../transformer';
-import { Procedure as OldProcedure } from './internals/procedure';
-import { ProcedureRecord } from './router';
+import type { TRPCErrorShape } from '../rpc';
+import type { CombinedDataTransformer } from '../transformer';
+import type { Procedure as OldProcedure } from './internals/procedure';
+import type { ProcedureRecord } from './router';
 
 type AnyOldProcedure = OldProcedure<any, any, any, any, any, any, any, any>;
 

package/src/deprecated/router.ts

@@ -2,23 +2,22 @@
 import { defaultFormatter } from '../error/formatter';
 import { TRPCError } from '../error/TRPCError';
 import { getHTTPStatusCodeFromError } from '../http/getHTTPStatusCode';
-import { inferObservableValue, Observable } from '../observable';
-import {
+import type { inferObservableValue, Observable } from '../observable';
+import type {
   TRPC_ERROR_CODE_KEY,
   TRPC_ERROR_CODE_NUMBER,
-  TRPC_ERROR_CODES_BY_KEY,
   TRPCErrorShape,
 } from '../rpc';
-import {
+import { TRPC_ERROR_CODES_BY_KEY } from '../rpc';
+import type {
   CombinedDataTransformer,
   DataTransformerOptions,
   DefaultDataTransformer,
-  defaultTransformer,
 } from '../transformer';
-import { FlatOverwrite, ThenArg } from '../types';
-import { MiddlewareFunction } from './internals/middlewares';
-import {
-  createProcedure,
+import { defaultTransformer } from '../transformer';
+import type { FlatOverwrite, ThenArg } from '../types';
+import type { MiddlewareFunction } from './internals/middlewares';
+import type {
   CreateProcedureOptions,
   CreateProcedureWithInput,
   CreateProcedureWithInputOutputParser,
@@ -27,7 +26,9 @@ import {
   Procedure,
   ProcedureCallOptions,
 } from './internals/procedure';
-import { MigrateRouter, migrateRouter } from './interop';
+import { createProcedure } from './internals/procedure';
+import type { MigrateRouter } from './interop';
+import { migrateRouter } from './interop';
 
 export type { Procedure } from './internals/procedure';
 

package/src/error/TRPCError.ts

@@ -1,4 +1,4 @@
-import { TRPC_ERROR_CODE_KEY } from '../rpc/codes';
+import type { TRPC_ERROR_CODE_KEY } from '../rpc/codes';
 import { getCauseFromUnknown } from '../shared/getCauseFromUnknown';
 
 export function getTRPCErrorFromUnknown(cause: unknown): TRPCError {
@@ -45,7 +45,7 @@ export class TRPCError extends Error {
     this.name = 'TRPCError';
 
     if (!this.cause) {
-      // idk why this is needed, but it is
+      // < ES2022 / < Node 16.9.0 compatability
       this.cause = cause;
     }
   }

package/src/error/formatter.ts

@@ -1,10 +1,10 @@
-import { ProcedureType } from '../core';
-import {
+import type { ProcedureType } from '../core';
+import type {
   TRPC_ERROR_CODE_KEY,
   TRPC_ERROR_CODE_NUMBER,
   TRPCErrorShape,
 } from '../rpc';
-import { TRPCError } from './TRPCError';
+import type { TRPCError } from './TRPCError';
 
 /**
  * @internal

package/src/http/contentType.ts

@@ -1,9 +1,9 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { AnyRouter } from '../core';
+import type { AnyRouter } from '../core';
 import { TRPCError } from '../error/TRPCError';
-import { CombinedDataTransformer } from '../transformer';
-import { MaybePromise } from '../types';
-import { HTTPRequest } from './types';
+import type { CombinedDataTransformer } from '../transformer';
+import type { MaybePromise } from '../types';
+import type { HTTPRequest } from './types';
 
 type GetInputs = (opts: {
   req: HTTPRequest;

package/src/http/getHTTPStatusCode.ts

@@ -1,6 +1,7 @@
-import { TRPCError } from '../error/TRPCError';
+import type { TRPCError } from '../error/TRPCError';
 import { invert } from '../internals/invert';
-import { TRPC_ERROR_CODES_BY_KEY, TRPCResponse } from '../rpc';
+import type { TRPCResponse } from '../rpc';
+import { TRPC_ERROR_CODES_BY_KEY } from '../rpc';
 
 export const TRPC_ERROR_CODES_BY_NUMBER = invert(TRPC_ERROR_CODES_BY_KEY);
 type ValueOf<TType> = TType[keyof TType];

package/src/http/internals/types.ts

@@ -1,13 +1,13 @@
-import {
+import type {
   AnyRouter,
   inferRouterContext,
   inferRouterError,
   ProcedureType,
 } from '../../core';
-import { TRPCError } from '../../error/TRPCError';
-import { TRPCResponse } from '../../rpc';
-import { Dict } from '../../types';
-import { ResponseMeta } from '../types';
+import type { TRPCError } from '../../error/TRPCError';
+import type { TRPCResponse } from '../../rpc';
+import type { Dict } from '../../types';
+import type { ResponseMeta } from '../types';
 
 export type HTTPHeaders = Dict<string[] | string>;
 

package/src/http/resolveHTTPResponse.ts

@@ -1,22 +1,24 @@
-import {
+import type {
   AnyRouter,
-  callProcedure,
   inferRouterContext,
   inferRouterError,
   ProcedureType,
 } from '../core';
+import { callProcedure } from '../core';
 import { getTRPCErrorFromUnknown, TRPCError } from '../error/TRPCError';
-import { TRPCResponse } from '../rpc';
+import type { TRPCResponse } from '../rpc';
 import { getErrorShape } from '../shared/getErrorShape';
 import { transformTRPCResponse } from '../shared/transformTRPCResponse';
-import { Maybe } from '../types';
-import {
-  BaseContentTypeHandler,
-  getJsonContentTypeInputs,
-} from './contentType';
+import type { Maybe } from '../types';
+import type { BaseContentTypeHandler } from './contentType';
+import { getJsonContentTypeInputs } from './contentType';
 import { getHTTPStatusCode } from './getHTTPStatusCode';
-import { HTTPHeaders, HTTPResponse, ResponseChunk } from './internals/types';
-import { HTTPBaseHandlerOptions, HTTPRequest } from './types';
+import type {
+  HTTPHeaders,
+  HTTPResponse,
+  ResponseChunk,
+} from './internals/types';
+import type { HTTPBaseHandlerOptions, HTTPRequest } from './types';
 
 const HTTP_METHOD_PROCEDURE_TYPE_MAP: Record<
   string,

package/src/http/types.ts

@@ -1,6 +1,6 @@
-import { AnyRouter } from '../core';
-import { BaseHandlerOptions } from '../internals/types';
-import { HTTPHeaders, ResponseMetaFn } from './internals/types';
+import type { AnyRouter } from '../core';
+import type { BaseHandlerOptions } from '../internals/types';
+import type { HTTPHeaders, ResponseMetaFn } from './internals/types';
 
 export interface HTTPRequest {
   method: string;

package/src/internals/types.ts

@@ -1,6 +1,6 @@
-import { inferRouterContext, ProcedureType } from '../core';
-import { AnyRouter } from '../core/router';
-import { TRPCError } from '../error/TRPCError';
+import type { inferRouterContext, ProcedureType } from '../core';
+import type { AnyRouter } from '../core/router';
+import type { TRPCError } from '../error/TRPCError';
 
 /**
  * Base interface for any response handler

package/src/observable/internals/observableToPromise.ts

@@ -1,4 +1,4 @@
-import { Observable } from '../types';
+import type { Observable } from '../types';
 
 export class ObservableAbortError extends Error {
   constructor(message: string) {

package/src/observable/internals/pipe.ts

@@ -1,4 +1,4 @@
-import { UnaryFunction } from '../types';
+import type { UnaryFunction } from '../types';
 import { identity } from './identity';
 
 /** @internal */

package/src/observable/observable.ts

@@ -1,5 +1,10 @@
 import { pipeFromArray } from './internals/pipe';
-import { Observable, Observer, OperatorFunction, TeardownLogic } from './types';
+import type {
+  Observable,
+  Observer,
+  OperatorFunction,
+  TeardownLogic,
+} from './types';
 
 export type inferObservableValue<TObservable> = TObservable extends Observable<
   infer TValue,

package/src/observable/operators/map.ts

@@ -1,4 +1,4 @@
-import { OperatorFunction } from '../types';
+import type { OperatorFunction } from '../types';
 
 export function map<TValueBefore, TError, TValueAfter>(
   project: (value: TValueBefore, index: number) => TValueAfter,

package/src/observable/operators/share.ts

@@ -1,4 +1,8 @@
-import { MonoTypeOperatorFunction, Observer, Unsubscribable } from '../types';
+import type {
+  MonoTypeOperatorFunction,
+  Observer,
+  Unsubscribable,
+} from '../types';
 
 interface ShareConfig {}
 export function share<TValue, TError>(