effect-app 4.0.0-beta.18 → 4.0.0-beta.180

package/src/client/errors.ts

@@ -1,19 +1,20 @@
 /** @effect-diagnostics overriddenSchemaConstructor:skip-file */
-import { TaggedError } from "effect-app/Schema"
+import { TaggedErrorClass } from "effect-app/Schema"
 import * as Cause from "effect/Cause"
 import * as S from "../Schema.js"
 
-export const tryToJson = (error: { toJSON(): unknown; toString(): string }) => {
+export const tryToJson = (error: unknown) => {
   try {
-    return error.toJSON()
+    const errorJson = (error as any).toJSON()
+    return errorJson && typeof errorJson === "object" ? errorJson as Record<string, unknown> : { error }
   } catch {
     try {
-      return error.toString()
+      return { error: (error as any).toString() }
     } catch (err) {
       try {
-        return `Failed to convert error: ${err}`
+        return { error: `Failed to convert error: ${err}` }
       } catch {
-        return `Failed to convert error: unknown failure`
+        return { error: `Failed to convert error: unknown failure` }
       }
     }
   }
@@ -21,7 +22,7 @@ export const tryToJson = (error: { toJSON(): unknown; toString(): string }) => {
 
 // eslint-disable-next-line unused-imports/no-unused-vars
 // @ts-expect-error type not used
-export class NotFoundError<ItemType = string> extends TaggedError<NotFoundError<ItemType>>()("NotFoundError", {
+export class NotFoundError<ItemType = string> extends TaggedErrorClass<NotFoundError<ItemType>>()("NotFoundError", {
   type: S.String,
   id: S.Unknown
 }) {
@@ -29,76 +30,97 @@ export class NotFoundError<ItemType = string> extends TaggedError<NotFoundError<
     props: { type: string; id: unknown; cause?: unknown },
     disableValidation?: boolean
   ) {
-    super(props as any, disableValidation as any)
+    super(props, disableValidation as any)
   }
   override get message() {
     return `Didn't find ${(this as any).type}#${JSON.stringify((this as any).id)}`
   }
+  override toString() {
+    return `NotFoundError: ${this.message}`
+  }
 }
 
 const messageFallback = (messageOrObject?: string | { message: string }) =>
   typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject ?? "" }
 
-export class InvalidStateError extends TaggedError<InvalidStateError>()("InvalidStateError", {
+export class InvalidStateError extends TaggedErrorClass<InvalidStateError>()("InvalidStateError", {
   message: S.String
 }) {
   constructor(messageOrObject: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
     super(
-      typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject } as any,
+      typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject },
       disableValidation as any
     )
   }
+  override toString() {
+    return `InvalidStateError: ${this.message}`
+  }
 }
 
-export class ServiceUnavailableError extends TaggedError<ServiceUnavailableError>()("ServiceUnavailableError", {
+export class ServiceUnavailableError extends TaggedErrorClass<ServiceUnavailableError>()("ServiceUnavailableError", {
   message: S.String
 }) {
   constructor(messageOrObject: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
     super(
-      typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject } as any,
+      typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject },
       disableValidation as any
     )
   }
+  override toString() {
+    return `ServiceUnavailableError: ${this.message}`
+  }
 }
 
-export class ValidationError extends TaggedError<ValidationError>()("ValidationError", {
+export class ValidationError extends TaggedErrorClass<ValidationError>()("ValidationError", {
   errors: S.Array(S.Unknown)
 }) {
   constructor(
     props: { errors: ReadonlyArray<unknown>; cause?: unknown },
     disableValidation?: boolean
   ) {
-    super(props as any, disableValidation as any)
+    super(props, disableValidation as any)
   }
   override get message() {
     return `Validation failed: ${(this as any).errors.map((e: any) => JSON.stringify(e, undefined, 2)).join(",\n")}`
   }
+  override toString() {
+    return `ValidationError: ${this.message}`
+  }
 }
 
-export class NotLoggedInError extends TaggedError<NotLoggedInError>()("NotLoggedInError", {
+export class NotLoggedInError extends TaggedErrorClass<NotLoggedInError>()("NotLoggedInError", {
   message: S.String
 }) {
   constructor(messageOrObject?: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
-    super(messageFallback(messageOrObject) as any, disableValidation as any)
+    super(messageFallback(messageOrObject), disableValidation as any)
+  }
+  override toString() {
+    return `NotLoggedInError: ${this.message}`
   }
 }
 
 /**
  * The user carries a valid Userprofile, but there is a problem with the login none the less.
  */
-export class LoginError extends TaggedError<LoginError>()("NotLoggedInError", {
+export class LoginError extends TaggedErrorClass<LoginError>()("NotLoggedInError", {
   message: S.String
 }) {
   constructor(messageOrObject?: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
-    super(messageFallback(messageOrObject) as any, disableValidation as any)
+    super(messageFallback(messageOrObject), disableValidation as any)
+  }
+  override toString() {
+    return `LoginError: ${this.message}`
   }
 }
 
-export class UnauthorizedError extends TaggedError<UnauthorizedError>()("UnauthorizedError", {
+export class UnauthorizedError extends TaggedErrorClass<UnauthorizedError>()("UnauthorizedError", {
   message: S.String
 }) {
   constructor(messageOrObject?: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
-    super(messageFallback(messageOrObject) as any, disableValidation as any)
+    super(messageFallback(messageOrObject), disableValidation as any)
+  }
+  override toString() {
+    return `UnauthorizedError: ${this.message}`
   }
 }
 
@@ -110,7 +132,7 @@ type OptimisticConcurrencyDetails = {
   readonly found?: string | undefined
 }
 
-export class OptimisticConcurrencyException extends TaggedError<OptimisticConcurrencyException>()(
+export class OptimisticConcurrencyException extends TaggedErrorClass<OptimisticConcurrencyException>()(
   "OptimisticConcurrencyException",
   { message: S.String }
 ) {
@@ -123,13 +145,16 @@ export class OptimisticConcurrencyException extends TaggedError<OptimisticConcur
     disableValidation?: boolean
   ) {
     super(
-      "message" in args ? args : { message: `Existing ${args.type} ${args.id} record changed` } as any,
+      "message" in args ? args : { message: `Existing ${args.type} ${args.id} record changed` },
       disableValidation as any
     )
     if (!("message" in args)) {
       this.details = args
     }
   }
+  override toString() {
+    return `OptimisticConcurrencyException: ${this.message}`
+  }
 }
 
 const MutationOnlyErrors = [
@@ -183,6 +208,7 @@ export class CauseException<E> extends Error {
     Error.stackTraceLimit = 0
     super()
     Error.stackTraceLimit = limit
+    this.cause = Cause.squash(originalCause)
     // v4: makeFiberFailure removed — use Cause.prettyErrors instead
     const errors = Cause.prettyErrors(originalCause)
     const first = errors[0]
@@ -222,17 +248,17 @@ export class CauseException<E> extends Error {
   }
 }
 
-export const tryToReport = (error: { toReport(): unknown; toString(): string }) => {
+export const tryToReport = (error: { toReport(): Record<string, unknown>; toString(): string }) => {
   try {
     return error.toReport()
   } catch {
     try {
-      return error.toString()
+      return { error: error.toString() }
     } catch (err) {
       try {
-        return `Failed to convert error: ${err}`
+        return { error: `Failed to convert error: ${err}` }
       } catch {
-        return `Failed to convert error: unknown failure`
+        return { error: `Failed to convert error: unknown failure` }
       }
     }
   }

package/src/client/makeClient.ts

@@ -1,3 +1,5 @@
+import { SchemaTransformation } from "effect"
+import type * as Exit from "effect/Exit"
 import { type GetContextConfig, type GetEffectError, type RequestContextMapTagAny } from "../rpc/RpcContextMap.js"
 import * as S from "../Schema.js"
 import { AST } from "../Schema.js"
@@ -8,36 +10,111 @@ const merge = (a: any, b: Array<any>) =>
 /**
  * Whatever the input, we will only decode or encode to void
  */
-const ForceVoid: S.Codec<void> = S.Void as any
+export const ForceVoid = S
+  .declare((_: unknown): _ is unknown => true)
+  .pipe(
+    S.decodeTo(S.Any, SchemaTransformation.transform<unknown, unknown>({ decode: () => void 0, encode: () => void 0 }))
+  )
 
 type SchemaOrFields<T> = T extends S.Top ? T : T extends S.Struct.Fields ? S.Struct<T> : S.Void
 
-type TaggedRequestResult<
+type TaggedRequestSchema<Tag extends string, Payload extends S.Struct.Fields> = S.Struct<
+  { readonly _tag: S.tag<Tag> } & Payload
+>
+
+type QueryOnlyRequests<Resource> = {
+  [K in keyof Resource as Resource[K] extends { readonly type: "query" } ? K : never]: Resource[K]
+}
+
+type QueryOnlyResources<Resources> = {
+  [K in keyof Resources]: QueryOnlyRequests<Resources[K]>
+}
+
+type InputFromPayload<Payload extends S.Struct.Fields> = keyof Payload extends never ? void
+  : S.Schema.Type<S.Struct<Payload>>
+
+type OutputFromSuccess<Success extends S.Top> = Success extends typeof ForceVoid ? void : S.Schema.Type<Success>
+
+type InvalidationResources = Record<string, Record<string, unknown>>
+
+export type InvalidateQueryInstruction = {
+  readonly filters?: Record<string, unknown>
+  readonly options?: Record<string, unknown>
+}
+
+export type InvalidationCallback<Resources, Input = unknown, Success = unknown, Failure = unknown> = (
+  queryKey: readonly string[],
+  resources: QueryOnlyResources<Resources>,
+  ...args: [Input] extends [void] ? [exit: Exit.Exit<Success, Failure>]
+    : [input: Input, exit: Exit.Exit<Success, Failure>]
+) => ReadonlyArray<InvalidateQueryInstruction>
+
+export type InvalidationConfig<Resources, Input = unknown, Success = unknown, Failure = unknown> = {
+  readonly invalidatesQueries: InvalidationCallback<Resources, Input, Success, Failure>
+  readonly invalidationResources?: Resources
+}
+
+type InvalidationConfigForCommand<
+  Resources,
+  Payload extends S.Struct.Fields,
+  Success extends S.Top,
+  Error extends S.Top
+> = InvalidationConfig<
+  Resources,
+  InputFromPayload<Payload>,
+  OutputFromSuccess<Success>,
+  S.Schema.Type<Error>
+>
+
+export const configureInvalidation = <Resources>() =>
+<Input, Success, Failure>(
+  invalidatesQueries: InvalidationCallback<Resources, NoInfer<Input>, NoInfer<Success>, NoInfer<Failure>>
+): InvalidationConfig<Resources, Input, Success, Failure> => ({ invalidatesQueries })
+
+export const configureInvalidationCallback = <Resources>() =>
+<Input, Success, Failure>(
+  invalidatesQueries: InvalidationCallback<Resources, NoInfer<Input>, NoInfer<Success>, NoInfer<Failure>>
+): InvalidationCallback<Resources, Input, Success, Failure> => invalidatesQueries
+
+export const configureInvalidationResources = <Resources>() =>
+  ({}) as Pick<InvalidationConfig<Resources>, "invalidationResources">
+
+type TaggedRequestForResult<
+  Self,
   Tag extends string,
   Payload extends S.Struct.Fields,
   Success extends S.Top,
   Error extends S.Top,
-  Config = Record<string, never>
+  Config,
+  ModuleName extends string,
+  Type extends "command" | "query" | "stream",
+  Resources = never,
+  Final extends S.Top = never
 > =
-  & S.TaggedStruct<Tag, Payload>
+  & S.EnhancedClass<Self, TaggedRequestSchema<Tag, Payload>, {}>
   & {
-    new(...args: any[]): any
     readonly _tag: Tag
-    readonly fields: { readonly _tag: S.tag<Tag> } & Payload
     readonly success: Success
     readonly error: Error
     readonly config: Config
     readonly "~decodingServices": S.Codec.DecodingServices<Success> | S.Codec.DecodingServices<Error>
+    readonly "~encodingServices": S.Codec.EncodingServices<Success> | S.Codec.EncodingServices<Error>
+    readonly id: `${ModuleName}.${Tag}`
+    readonly moduleName: ModuleName
+    readonly type: Type
+    readonly "~invalidationResources"?: Resources
   }
+  & ([Final] extends [never] ? {} : { readonly final: Final })
 
 export const makeRpcClient = <
   RequestContextMap extends RequestContextMapTagAny,
   GeneralErrors extends S.Top = never
 >(rcs: RequestContextMap, generalErrors?: GeneralErrors) => {
-  // Long way around ServiceMap/C extends etc to support actual jsdoc from passed in RequestConfig etc... (??)
+  // Long way around Context/C extends etc to support actual jsdoc from passed in RequestConfig etc... (??)
   type ServiceMap = {
     success: S.Top | S.Struct.Fields // SchemaOrFields will make a Schema type out of Struct.Fields
     error: S.Top | S.Struct.Fields // SchemaOrFields will make a Schema type out of Struct.Fields
+    final?: S.Top | S.Struct.Fields // optional final-value schema for stream requests
   }
 
   type RequestConfig = GetContextConfig<RequestContextMap["config"]>
@@ -47,64 +124,263 @@ export const makeRpcClient = <
     : [GeneralErrors] extends [never] ? GetEffectError<RequestContextMap["config"], C>
     : MergeError<GetEffectError<RequestContextMap["config"], C>>
 
-  function TaggedRequest<_Self>(): {
-    <Tag extends string, Payload extends S.Struct.Fields, C extends ServiceMap>(
-      tag: Tag,
-      fields: Payload,
-      config: RequestConfig & C
-    ): TaggedRequestResult<Tag, Payload, SchemaOrFields<C["success"]>, ErrorResult<C>, Omit<C, "success" | "error">>
-    <Tag extends string, Payload extends S.Struct.Fields, C extends Pick<ServiceMap, "success">>(
-      tag: Tag,
-      fields: Payload,
-      config: RequestConfig & C
-    ): TaggedRequestResult<Tag, Payload, SchemaOrFields<C["success"]>, ErrorResult<C>, Omit<C, "success" | "error">>
-    <Tag extends string, Payload extends S.Struct.Fields, C extends Pick<ServiceMap, "error">>(
-      tag: Tag,
-      fields: Payload,
-      config: RequestConfig & C
-    ): TaggedRequestResult<Tag, Payload, S.Codec<void>, ErrorResult<C>, Omit<C, "success" | "error">>
-    <Tag extends string, Payload extends S.Struct.Fields, C extends Record<string, any>>(
-      tag: Tag,
-      fields: Payload,
-      config: C & RequestConfig
-    ): TaggedRequestResult<Tag, Payload, S.Codec<void>, ErrorResult<C>, Omit<C, "success" | "error">>
-    <Tag extends string, Payload extends S.Struct.Fields>(
-      tag: Tag,
-      fields: Payload
-    ): TaggedRequestResult<Tag, Payload, S.Codec<void>, ErrorResult<never>, Record<string, never>>
-  } {
-    // TODO: filter errors based on config + take care of inversion
-    const errorSchemas = Object.values(rcs.config).map((_) => _.error)
-    return (<Tag extends string, Fields extends S.Struct.Fields, C extends ServiceMap>(
-      tag: Tag,
-      fields: Fields,
-      config?: C
-    ) => {
-      // TODO: S.TaggedRequest removed in v4 — needs rework to use Rpc.make or Request.TaggedClass
-      // For now, creating a simple tagged struct class with success/failure properties
-      const failureSchema = merge(
-        config?.error ? S.isSchema(config.error) ? config.error : S.Struct(config.error) : undefined,
-        [...errorSchemas, generalErrors].filter(Boolean)
-      )
-      const successSchema = config?.success
-        ? S.isSchema(config.success)
-          ? AST.isVoid(config.success.ast) ? ForceVoid : config.success
-          : S.Struct(config.success)
-        : ForceVoid
-
-      const RequestClass = S.TaggedClass<any>()(tag, fields)
-      Object.assign(RequestClass, {
-        _tag: tag,
-        success: successSchema,
-        error: failureSchema,
-        config
-      })
-
-      return RequestClass
-    }) as any
+  // TODO: filter errors based on config + take care of inversion
+  const errorSchemas = Object.values(rcs.config).map((_) => _.error)
+
+  function makeRequestClass<Tag extends string, Fields extends S.Struct.Fields, C extends Partial<ServiceMap>>(
+    tag: Tag,
+    fields: Fields,
+    config?: C
+  ) {
+    const failureSchema = merge(
+      config?.error ? S.isSchema(config.error) ? config.error : S.Struct(config.error) : undefined,
+      [...errorSchemas, generalErrors].filter(Boolean)
+    )
+    const successSchema = config?.success
+      ? S.isSchema(config.success)
+        ? AST.isVoid(config.success.ast) ? ForceVoid : config.success
+        : S.Struct(config.success)
+      : ForceVoid
+
+    const finalConfig = (config as any)?.final
+    const finalSchema = finalConfig && S.isSchema(finalConfig) ? finalConfig : undefined
+
+    const RequestClass = S.TaggedClass<any>()(tag, fields)
+    Object.assign(RequestClass, {
+      _tag: tag,
+      success: successSchema,
+      error: failureSchema,
+      ...(finalSchema !== undefined ? { final: finalSchema } : {}),
+      config
+    })
+
+    return RequestClass
+  }
+
+  function makeTaggedRequestWithMeta<ModuleName extends string, Type extends "command" | "query" | "stream">(
+    moduleName: ModuleName,
+    type: Type
+  ) {
+    function TaggedRequestWithMeta<Self, Resources extends InvalidationResources = never>(): {
+      <
+        Tag extends string,
+        Payload extends S.Struct.Fields,
+        Success extends S.Top | S.Struct.Fields,
+        Error extends S.Top | S.Struct.Fields,
+        Final extends S.Top | S.Struct.Fields = never,
+        C extends RequestConfig & Record<string, any> = RequestConfig & Record<string, any>
+      >(
+        tag: Tag,
+        fields: Payload,
+        config:
+          & Omit<C, "invalidatesQueries">
+          & { success: Success; error: Error; final?: Final },
+        invalidatesQueries?: InvalidationCallback<
+          Resources,
+          InputFromPayload<Payload>,
+          OutputFromSuccess<SchemaOrFields<Success>>,
+          S.Schema.Type<ErrorResult<C & { success: Success; error: Error }>>
+        >
+      ): TaggedRequestForResult<
+        Self,
+        Tag,
+        Payload,
+        SchemaOrFields<Success>,
+        ErrorResult<C & { success: Success; error: Error }>,
+        Omit<
+          & Omit<C, "invalidatesQueries">
+          & {
+            success: Success
+            error: Error
+          }
+          & Partial<
+            InvalidationConfigForCommand<
+              Resources,
+              Payload,
+              SchemaOrFields<Success>,
+              ErrorResult<C & { success: Success; error: Error }>
+            >
+          >,
+          "success" | "error"
+        >,
+        ModuleName,
+        Type,
+        Resources,
+        [Final] extends [never] ? never : SchemaOrFields<Final>
+      >
+      <
+        Tag extends string,
+        Payload extends S.Struct.Fields,
+        Success extends S.Top | S.Struct.Fields,
+        Final extends S.Top | S.Struct.Fields = never,
+        C extends RequestConfig & Record<string, any> & { error?: never } = RequestConfig & Record<string, any> & {
+          error?: never
+        }
+      >(
+        tag: Tag,
+        fields: Payload,
+        config:
+          & Omit<C, "invalidatesQueries">
+          & { success: Success; final?: Final },
+        invalidatesQueries?: InvalidationCallback<
+          Resources,
+          InputFromPayload<Payload>,
+          OutputFromSuccess<SchemaOrFields<Success>>,
+          S.Schema.Type<ErrorResult<C & { success: Success }>>
+        >
+      ): TaggedRequestForResult<
+        Self,
+        Tag,
+        Payload,
+        SchemaOrFields<Success>,
+        ErrorResult<C & { success: Success }>,
+        Omit<
+          & Omit<C, "invalidatesQueries">
+          & {
+            success: Success
+          }
+          & Partial<
+            InvalidationConfigForCommand<
+              Resources,
+              Payload,
+              SchemaOrFields<Success>,
+              ErrorResult<C & { success: Success }>
+            >
+          >,
+          "success" | "error"
+        >,
+        ModuleName,
+        Type,
+        Resources,
+        [Final] extends [never] ? never : SchemaOrFields<Final>
+      >
+      <
+        Tag extends string,
+        Payload extends S.Struct.Fields,
+        Error extends S.Top | S.Struct.Fields,
+        C extends RequestConfig & Record<string, any> & { success?: never }
+      >(
+        tag: Tag,
+        fields: Payload,
+        config:
+          & Omit<C, "invalidatesQueries">
+          & { error: Error },
+        invalidatesQueries?: InvalidationCallback<
+          Resources,
+          InputFromPayload<Payload>,
+          void,
+          S.Schema.Type<ErrorResult<C & { error: Error }>>
+        >
+      ): TaggedRequestForResult<
+        Self,
+        Tag,
+        Payload,
+        typeof ForceVoid,
+        ErrorResult<C & { error: Error }>,
+        Omit<
+          & Omit<C, "invalidatesQueries">
+          & {
+            error: Error
+          }
+          & Partial<
+            InvalidationConfigForCommand<
+              Resources,
+              Payload,
+              typeof ForceVoid,
+              ErrorResult<C & { error: Error }>
+            >
+          >,
+          "success" | "error"
+        >,
+        ModuleName,
+        Type,
+        Resources
+      >
+      <
+        Tag extends string,
+        Payload extends S.Struct.Fields,
+        C extends RequestConfig & Record<string, any> & { success?: never; error?: never }
+      >(
+        tag: Tag,
+        fields: Payload,
+        config: Omit<C, "invalidatesQueries">,
+        invalidatesQueries?: InvalidationCallback<
+          Resources,
+          InputFromPayload<Payload>,
+          void,
+          S.Schema.Type<ErrorResult<C>>
+        >
+      ): TaggedRequestForResult<
+        Self,
+        Tag,
+        Payload,
+        typeof ForceVoid,
+        ErrorResult<C>,
+        Omit<
+          & Omit<C, "invalidatesQueries">
+          & Partial<InvalidationConfigForCommand<Resources, Payload, typeof ForceVoid, ErrorResult<C>>>,
+          "success" | "error"
+        >,
+        ModuleName,
+        Type,
+        Resources
+      >
+      <Tag extends string, Payload extends S.Struct.Fields>(
+        tag: Tag,
+        fields: Payload
+      ): TaggedRequestForResult<
+        Self,
+        Tag,
+        Payload,
+        typeof ForceVoid,
+        ErrorResult<{}>,
+        Record<string, never>,
+        ModuleName,
+        Type
+      >
+    } {
+      return (<Tag extends string, Fields extends S.Struct.Fields, C extends ServiceMap>(
+        tag: Tag,
+        fields: Fields,
+        config?: C,
+        invalidatesQueries?: InvalidationCallback<Resources, unknown, unknown, unknown>
+      ) => {
+        const requestConfig = invalidatesQueries === undefined ? config : { ...config, invalidatesQueries }
+        const cls = makeRequestClass(tag, fields, requestConfig)
+        Object.assign(cls, { id: `${moduleName}.${tag}`, moduleName, type })
+        return cls
+      }) as any
+    }
+    return Object.assign(TaggedRequestWithMeta, { moduleName, type } as const)
+  }
+
+  function TaggedRequestFor<ModuleName extends string>(moduleName: ModuleName) {
+    const Query = makeTaggedRequestWithMeta(moduleName, "query")
+    const Command = makeTaggedRequestWithMeta(moduleName, "command")
+    const Stream = makeTaggedRequestWithMeta(moduleName, "stream")
+
+    return {
+      moduleName,
+      /**
+       * Create query request classes for this module.
+       * Queries read state and should not mutate server state.
+       */
+      Query,
+      /**
+       * Create command request classes for this module.
+       * Commands mutate state and should avoid returning complex read models.
+       */
+      Command,
+      /**
+       * Create stream request classes for this module.
+       * Streams produce a Stream of `success` values, may also fail with `error`.
+       * Handlers must return an `Effect`-compatible Stream rather than an Effect.
+       */
+      Stream
+    } as const
   }
 
   return {
-    TaggedRequest
+    TaggedRequestFor
   }
 }

package/src/client.ts

@@ -2,5 +2,6 @@
 export * from "./client/apiClientFactory.js"
 export * from "./client/clientFor.js"
 export * from "./client/errors.js"
+export * from "./client/InvalidationKeys.js"
 export * from "./client/makeClient.js"
 // codegen:end