effect-cf 0.7.0 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {
@@ -21,6 +21,11 @@
       "import": "./dist/index.mjs",
       "default": "./dist/index.mjs"
     },
+    "./hyperdrive-pg": {
+      "types": "./dist/HyperdrivePg.d.mts",
+      "import": "./dist/HyperdrivePg.mjs",
+      "default": "./dist/HyperdrivePg.mjs"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -37,6 +42,7 @@
     "@cloudflare/vitest-pool-workers": "^0.15.0",
     "@cloudflare/workers-types": "^4.20260421.1",
     "@effect/sql-d1": "catalog:",
+    "@effect/sql-pg": "4.0.0-beta.65",
     "@effect/vitest": "catalog:",
     "effect": "catalog:",
     "typescript": "^6.0.2",
@@ -45,6 +51,12 @@
   },
   "peerDependencies": {
     "@effect/sql-d1": "^4.0.0-beta.65",
+    "@effect/sql-pg": "^4.0.0-beta.65",
     "effect": "^4.0.0-beta.65"
+  },
+  "peerDependenciesMeta": {
+    "@effect/sql-pg": {
+      "optional": true
+    }
   }
 }

package/src/D1.ts

@@ -1,17 +1,10 @@
 import { D1Client } from "@effect/sql-d1";
-import { Data, Effect, Layer } from "effect";
+import { Effect, Layer } from "effect";
 
 import * as Binding from "./Binding";
 
 const TypeId = "effect-cf/D1" as const;
 
-/** Error raised when a D1 operation fails. */
-export class D1OperationError extends Data.TaggedError("D1OperationError")<{
-  readonly binding: string;
-  readonly operation: string;
-  readonly cause: unknown;
-}> {}
-
 /** Typed D1 binding definition. */
 export interface D1Definition {
   /** Binding name as configured in `wrangler.jsonc`. */
@@ -44,29 +37,6 @@ const isD1Database = (value: unknown): value is D1Database => {
   );
 };
 
-const d1Error = (binding: string, operation: string, cause: unknown) =>
-  new D1OperationError({ binding, operation, cause });
-
-const tryD1Promise = <A>(
-  binding: string,
-  operation: string,
-  evaluate: () => Promise<A>,
-): Effect.Effect<A, D1OperationError> =>
-  Effect.tryPromise({
-    try: evaluate,
-    catch: (cause) => d1Error(binding, operation, cause),
-  });
-
-const tryD1Sync = <A>(
-  binding: string,
-  operation: string,
-  evaluate: () => A,
-): Effect.Effect<A, D1OperationError> =>
-  Effect.try({
-    try: evaluate,
-    catch: (cause) => d1Error(binding, operation, cause),
-  });
-
 /**
  * Creates a typed D1 service tag plus Effect helpers.
  */
@@ -76,9 +46,8 @@ export const make = <Id extends string>(id: Id, definition: D1Definition) =>
 /**
  * Builds a D1 service around a Cloudflare D1 database binding.
  *
- * The returned service exposes the raw `D1Database` binding, small native D1
- * helpers, and `sqlLayer(...)` for providing `effect/unstable/sql` via
- * `@effect/sql-d1`.
+ * The returned service exposes the raw `D1Database` binding and `sqlLayer(...)`
+ * for providing `effect/unstable/sql` via `@effect/sql-d1`.
  *
  * @example
  * ```ts
@@ -102,34 +71,9 @@ export const Service =
         }),
       ).pipe(Layer.provide(tag.layer));
 
-    const prepare = Effect.fnUntraced(function* (query: string) {
-      const db = yield* tag;
-      return yield* tryD1Sync(definition.binding, "prepare", () => db.prepare(query));
-    });
-
-    const batch = Effect.fnUntraced(function* <T = unknown>(
-      statements: ReadonlyArray<D1PreparedStatement>,
-    ) {
-      const db = yield* tag;
-      return yield* tryD1Promise(definition.binding, "batch", () => db.batch<T>([...statements]));
-    });
-
-    const exec = Effect.fnUntraced(function* (query: string) {
-      const db = yield* tag;
-      return yield* tryD1Promise(definition.binding, "exec", () => db.exec(query));
-    });
-
-    const unsafeRaw = Effect.fnUntraced(function* () {
-      return yield* tag;
-    });
-
     return Object.assign(tag, {
       [TypeId]: TypeId,
       definition,
       sqlLayer,
-      prepare,
-      batch,
-      exec,
-      unsafeRaw,
     });
   };

package/src/DurableObject.ts

@@ -73,6 +73,15 @@ export type RpcHandlers<ROut, Api> = {
  * Options for creating a Durable Object class backed by Effect handlers.
  */
 export interface DurableObjectOptions<ROut, Rpc extends DurableObjectRpc<ROut>> {
+  /**
+   * Effect run when Cloudflare loads this Durable Object instance into memory.
+   *
+   * Use `DurableObjectState.blockConcurrencyWhile` inside this hook when
+   * incoming events should wait for setup to finish. Cloudflare may construct
+   * the same Durable Object id again after eviction or restart; use Durable
+   * Object storage if work must happen only once per id.
+   */
+  readonly initialize?: Effect.Effect<void, unknown, HandlerContext<ROut>>;
   /** Optional RPC methods exposed as Durable Object instance methods. */
   readonly rpc?: Rpc;
   /** Optional fetch handler for HTTP/WebSocket requests. */
@@ -137,6 +146,11 @@ export const make = <
       const runtimeLayer = Entrypoint.provideEntrypointServices(layer, services);
 
       this.runtime = ManagedRuntime.make(runtimeLayer);
+
+      const initialize = options.initialize;
+      if (initialize !== undefined) {
+        state.waitUntil(this[RunSymbol](initialize));
+      }
     }
 
     [RunSymbol]<A, E>(effect: Effect.Effect<A, E, HandlerContext<ROut>>): Promise<A> {

package/src/Hyperdrive.ts

@@ -0,0 +1,82 @@
+import { Context, Effect, type Layer } from "effect";
+
+import * as Binding from "./Binding";
+import type { WorkerEnvironment } from "./Environment";
+
+/** Typed Hyperdrive binding definition. */
+export interface HyperdriveDefinition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+
+export interface HyperdriveClient {
+  readonly connectionString: string;
+  readonly unsafeRaw: Effect.Effect<Hyperdrive>;
+  readonly definition: HyperdriveDefinition;
+}
+
+declare const HyperdriveServiceTypeId: unique symbol;
+
+/** Nominal service marker for Hyperdrive services created with {@link make}. */
+export interface HyperdriveService<Id extends string> {
+  readonly [HyperdriveServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+
+export type LayerOptions = {
+  readonly binding: string;
+};
+
+export interface TagClass<Self, Id extends string> extends Context.ServiceClass<
+  Self,
+  Id,
+  HyperdriveClient
+> {
+  readonly id: Id;
+  readonly layer: (
+    options: LayerOptions,
+  ) => Layer.Layer<
+    Self,
+    Binding.BindingNotFoundError | Binding.BindingValidationError,
+    WorkerEnvironment
+  >;
+}
+
+export const isHyperdrive = (value: unknown): value is Hyperdrive => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+
+  const resource = value as Record<string, unknown>;
+
+  return typeof resource.connectionString === "string";
+};
+
+export const makeClient =
+  (definition: HyperdriveDefinition) =>
+  (hyperdrive: Hyperdrive): HyperdriveClient => ({
+    definition,
+    connectionString: hyperdrive.connectionString,
+    unsafeRaw: Effect.succeed(hyperdrive),
+  });
+
+export const layer = <Self>(
+  tag: Context.Service<Self, HyperdriveClient>,
+  definition: HyperdriveDefinition,
+) => Binding.layer(tag, definition.binding, isHyperdrive, makeClient(definition));
+
+export const make = <Id extends string>(id: Id) => Tag<HyperdriveService<Id>>()<Id>(id);
+
+export const Tag =
+  <Self>() =>
+  <Id extends string>(id: Id) => {
+    const tag = Context.Service<Self, HyperdriveClient>()(id);
+
+    const makeLayer = (definition: LayerOptions) => layer(tag, definition);
+
+    return Object.assign(tag, {
+      id,
+      layer: makeLayer,
+    }) as TagClass<Self, Id>;
+  };

package/src/HyperdrivePg.ts

@@ -0,0 +1,27 @@
+import { PgClient } from "@effect/sql-pg";
+import { Effect, Layer, Redacted } from "effect";
+
+import * as Hyperdrive from "./Hyperdrive";
+
+export type PgLayerOptions = Omit<
+  PgClient.PgClientConfig & { readonly acquireForStream?: boolean },
+  "url" | "host" | "port" | "path" | "ssl" | "database" | "username" | "password" | "stream"
+>;
+
+export const layer = <Self, Id extends string>(
+  tag: Hyperdrive.TagClass<Self, Id>,
+  binding: Hyperdrive.LayerOptions,
+  options?: PgLayerOptions,
+) =>
+  Layer.unwrap(
+    Effect.gen(function* () {
+      const hyperdrive = yield* tag;
+
+      return PgClient.layerFrom(
+        PgClient.makeClient({
+          ...options,
+          url: Redacted.make(hyperdrive.connectionString),
+        }),
+      );
+    }),
+  ).pipe(Layer.provide(tag.layer(binding)));

package/src/Images.ts

@@ -0,0 +1,332 @@
+import { Context, Data, Effect, Option, type Layer } from "effect";
+
+import * as Binding from "./Binding";
+import type { WorkerEnvironment } from "./Environment";
+
+const TypeId = "effect-cf/Images/Steps" as const;
+
+/** Error raised when a Cloudflare Images operation fails. */
+export class ImagesOperationError extends Data.TaggedError("ImagesOperationError")<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {}
+
+/** Typed Cloudflare Images binding definition. */
+export interface ImagesDefinition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+
+export type ImageInfoResponse = globalThis.ImageInfoResponse;
+export type ImageTransform = globalThis.ImageTransform;
+export type ImageDrawOptions = globalThis.ImageDrawOptions;
+export type ImageInputOptions = globalThis.ImageInputOptions;
+export type ImageOutputOptions = globalThis.ImageOutputOptions;
+export type ImageTransformationOutputOptions = globalThis.ImageTransformationOutputOptions;
+export type ImageTransformationResult = globalThis.ImageTransformationResult;
+export type ImageUploadOptions = globalThis.ImageUploadOptions;
+export type ImageUpdateOptions = globalThis.ImageUpdateOptions;
+export type ImageListOptions = globalThis.ImageListOptions;
+export type ImageList = globalThis.ImageList;
+export type ImageMetadata = globalThis.ImageMetadata;
+export type ImageInputValue = ReadableStream<Uint8Array> | ArrayBuffer;
+export type ImageUploadValue = ReadableStream<Uint8Array> | ArrayBuffer;
+
+export interface DrawStepOptions {
+  readonly image: ReadableStream<Uint8Array> | globalThis.ImageTransformer;
+  readonly options?: ImageDrawOptions;
+}
+
+export type Step = Data.TaggedEnum<{
+  readonly Transform: {
+    readonly transform: ImageTransform;
+  };
+  readonly Draw: DrawStepOptions;
+}>;
+
+export interface Steps {
+  readonly [TypeId]: typeof TypeId;
+  readonly steps: ReadonlyArray<Step>;
+}
+
+export interface ProcessOptions {
+  readonly stream: ImageInputValue;
+  readonly inputOptions?: ImageInputOptions;
+  readonly outputOptions: ImageOutputOptions;
+}
+
+export interface ImagesTransformationResultClient {
+  readonly raw: globalThis.ImageTransformationResult;
+  readonly response: Effect.Effect<globalThis.Response, ImagesOperationError>;
+  readonly contentType: Effect.Effect<string, ImagesOperationError>;
+  readonly image: (
+    options?: ImageTransformationOutputOptions,
+  ) => Effect.Effect<ReadableStream<Uint8Array>, ImagesOperationError>;
+}
+
+export interface ImageHandleClient {
+  readonly raw: globalThis.ImageHandle;
+  readonly details: Effect.Effect<Option.Option<ImageMetadata>, ImagesOperationError>;
+  readonly bytes: Effect.Effect<Option.Option<ReadableStream<Uint8Array>>, ImagesOperationError>;
+  readonly update: (
+    options: ImageUpdateOptions,
+  ) => Effect.Effect<ImageMetadata, ImagesOperationError>;
+  readonly delete: Effect.Effect<boolean, ImagesOperationError>;
+}
+
+export interface HostedImagesClient {
+  readonly image: (imageId: string) => ImageHandleClient;
+  readonly upload: (
+    image: ImageUploadValue,
+    options?: ImageUploadOptions,
+  ) => Effect.Effect<ImageMetadata, ImagesOperationError>;
+  readonly list: (options?: ImageListOptions) => Effect.Effect<ImageList, ImagesOperationError>;
+  readonly unsafeRaw: Effect.Effect<globalThis.HostedImagesBinding>;
+}
+
+export interface ImagesRuntimeBinding {
+  readonly info: (
+    image: ImageInputValue,
+    options?: ImageInputOptions,
+  ) => Promise<ImageInfoResponse>;
+  readonly input: (
+    image: ImageInputValue,
+    options?: ImageInputOptions,
+  ) => globalThis.ImageTransformer;
+  readonly hosted?: globalThis.HostedImagesBinding;
+}
+
+export interface ImagesClient {
+  readonly info: (
+    image: ImageInputValue,
+    options?: ImageInputOptions,
+  ) => Effect.Effect<ImageInfoResponse, ImagesOperationError>;
+  readonly input: (
+    image: ImageInputValue,
+    options?: ImageInputOptions,
+  ) => Effect.Effect<globalThis.ImageTransformer, ImagesOperationError>;
+  readonly process: (
+    steps: Steps,
+    options: ProcessOptions,
+  ) => Effect.Effect<ImagesTransformationResultClient, ImagesOperationError>;
+  readonly hosted: Option.Option<HostedImagesClient>;
+  readonly unsafeRaw: Effect.Effect<ImagesRuntimeBinding>;
+  readonly definition: ImagesDefinition;
+}
+
+declare const ImagesServiceTypeId: unique symbol;
+
+/** Nominal service marker for Images services created with {@link make}. */
+export interface ImagesService<Id extends string> {
+  readonly [ImagesServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+
+export type LayerOptions = {
+  readonly binding: string;
+};
+
+export interface TagClass<Self, Id extends string> extends Context.ServiceClass<
+  Self,
+  Id,
+  ImagesClient
+> {
+  readonly id: Id;
+  readonly layer: (
+    options: LayerOptions,
+  ) => Layer.Layer<
+    Self,
+    Binding.BindingNotFoundError | Binding.BindingValidationError,
+    WorkerEnvironment
+  >;
+}
+
+const makeSteps = (steps: ReadonlyArray<Step>): Steps => ({
+  [TypeId]: TypeId,
+  steps,
+});
+
+/** Empty Images transformation pipeline. */
+export const empty: Steps = makeSteps([]);
+
+export function transform(transform: ImageTransform): (steps: Steps) => Steps;
+export function transform(steps: Steps, transform: ImageTransform): Steps;
+export function transform(
+  stepsOrTransform: Steps | ImageTransform,
+  transformValue?: ImageTransform,
+): Steps | ((steps: Steps) => Steps) {
+  if (transformValue === undefined) {
+    return (steps) => transform(steps, stepsOrTransform as ImageTransform);
+  }
+
+  const steps = stepsOrTransform as Steps;
+
+  return makeSteps([
+    ...steps.steps,
+    {
+      _tag: "Transform",
+      transform: transformValue,
+    },
+  ]);
+}
+
+export function draw(draw: DrawStepOptions): (steps: Steps) => Steps;
+export function draw(steps: Steps, draw: DrawStepOptions): Steps;
+export function draw(
+  stepsOrDraw: Steps | DrawStepOptions,
+  drawValue?: DrawStepOptions,
+): Steps | ((steps: Steps) => Steps) {
+  if (drawValue === undefined) {
+    return (steps) => draw(steps, stepsOrDraw as DrawStepOptions);
+  }
+
+  const steps = stepsOrDraw as Steps;
+
+  return makeSteps([
+    ...steps.steps,
+    {
+      _tag: "Draw",
+      ...drawValue,
+    },
+  ]);
+}
+
+const imagesError = (binding: string, operation: string, cause: unknown) =>
+  new ImagesOperationError({ binding, operation, cause });
+
+const tryImagesPromise = <A>(
+  binding: string,
+  operation: string,
+  evaluate: () => Promise<A>,
+): Effect.Effect<A, ImagesOperationError> =>
+  Effect.tryPromise({
+    try: evaluate,
+    catch: (cause) => imagesError(binding, operation, cause),
+  });
+
+const tryImagesSync = <A>(
+  binding: string,
+  operation: string,
+  evaluate: () => A,
+): Effect.Effect<A, ImagesOperationError> =>
+  Effect.try({
+    try: evaluate,
+    catch: (cause) => imagesError(binding, operation, cause),
+  });
+
+const maybe = <A>(value: A | null): Option.Option<A> =>
+  value === null ? Option.none() : Option.some(value);
+
+const hasFunction = (value: object, key: string): boolean =>
+  typeof Reflect.get(value, key) === "function";
+
+const isHostedImagesBinding = (value: unknown): value is globalThis.HostedImagesBinding =>
+  typeof value === "object" &&
+  value !== null &&
+  hasFunction(value, "image") &&
+  hasFunction(value, "upload") &&
+  hasFunction(value, "list");
+
+export const isImagesBinding = (value: unknown): value is ImagesRuntimeBinding =>
+  typeof value === "object" &&
+  value !== null &&
+  hasFunction(value, "info") &&
+  hasFunction(value, "input");
+
+const wrapResult = (
+  binding: string,
+  result: globalThis.ImageTransformationResult,
+): ImagesTransformationResultClient => ({
+  raw: result,
+  response: tryImagesSync(binding, "response", () => result.response()),
+  contentType: tryImagesSync(binding, "contentType", () => result.contentType()),
+  image: (options) => tryImagesSync(binding, "image", () => result.image(options)),
+});
+
+const wrapHandle = (binding: string, handle: globalThis.ImageHandle): ImageHandleClient => ({
+  raw: handle,
+  details: tryImagesPromise(binding, "details", () => handle.details()).pipe(Effect.map(maybe)),
+  bytes: tryImagesPromise(binding, "bytes", () => handle.bytes()).pipe(Effect.map(maybe)),
+  update: (options) => tryImagesPromise(binding, "update", () => handle.update(options)),
+  delete: tryImagesPromise(binding, "delete", () => handle.delete()),
+});
+
+const wrapHosted = (
+  binding: string,
+  hosted: globalThis.HostedImagesBinding,
+): HostedImagesClient => ({
+  image: (imageId) => wrapHandle(binding, hosted.image(imageId)),
+  upload: (image, options) =>
+    tryImagesPromise(binding, "upload", () => hosted.upload(image, options)),
+  list: (options) => tryImagesPromise(binding, "list", () => hosted.list(options)),
+  unsafeRaw: Effect.succeed(hosted),
+});
+
+export const makeClient =
+  (definition: ImagesDefinition) =>
+  (images: ImagesRuntimeBinding): ImagesClient => {
+    const input = (image: ImageInputValue, options?: ImageInputOptions) =>
+      tryImagesSync(definition.binding, "input", () => images.input(image, options));
+
+    const process = (steps: Steps, options: ProcessOptions) =>
+      Effect.gen(function* () {
+        let transformer = yield* input(options.stream, options.inputOptions);
+
+        for (const step of steps.steps) {
+          switch (step._tag) {
+            case "Draw": {
+              transformer = yield* tryImagesSync(definition.binding, "draw", () =>
+                transformer.draw(step.image, step.options),
+              );
+              break;
+            }
+            case "Transform": {
+              transformer = yield* tryImagesSync(definition.binding, "transform", () =>
+                transformer.transform(step.transform),
+              );
+              break;
+            }
+          }
+        }
+
+        const result = yield* tryImagesPromise(definition.binding, "output", () =>
+          transformer.output(options.outputOptions),
+        );
+
+        return wrapResult(definition.binding, result);
+      });
+
+    return {
+      definition,
+      info: (image, options) =>
+        tryImagesPromise(definition.binding, "info", () => images.info(image, options)),
+      input,
+      process,
+      hosted: isHostedImagesBinding(images.hosted)
+        ? Option.some(wrapHosted(definition.binding, images.hosted))
+        : Option.none(),
+      unsafeRaw: Effect.succeed(images),
+    };
+  };
+
+export const layer = <Self>(
+  tag: Context.Service<Self, ImagesClient>,
+  definition: ImagesDefinition,
+) => Binding.layer(tag, definition.binding, isImagesBinding, makeClient(definition));
+
+export const make = <Id extends string>(id: Id) => Tag<ImagesService<Id>>()<Id>(id);
+
+export const Tag =
+  <Self>() =>
+  <Id extends string>(id: Id) => {
+    const tag = Context.Service<Self, ImagesClient>()(id);
+
+    const makeLayer = (definition: LayerOptions) => layer(tag, definition);
+
+    return Object.assign(tag, {
+      id,
+      layer: makeLayer,
+    }) as TagClass<Self, Id>;
+  };

package/src/Kv.ts

@@ -114,27 +114,6 @@ export interface TagClass<
     Binding.BindingNotFoundError | Binding.BindingValidationError,
     WorkerEnvironment
   >;
-  readonly put: (
-    key: Key,
-    value: Value,
-    options?: KvPutOptions,
-  ) => Effect.Effect<void, KvOperationError | S.SchemaError, Self>;
-  readonly get: (
-    key: Key,
-  ) => Effect.Effect<Option.Option<Value>, KvOperationError | S.SchemaError, Self>;
-  readonly getWithMetadata: <Metadata>(
-    key: Key,
-    metadataSchema: S.Codec<Metadata, unknown>,
-  ) => Effect.Effect<
-    Option.Option<KvWithMetadata<Value, Metadata>>,
-    KvOperationError | S.SchemaError,
-    Self
-  >;
-  readonly list: <Metadata = unknown>(
-    options?: KvListOptions<Metadata>,
-  ) => Effect.Effect<KvListResult<Key, Metadata>, KvOperationError | S.SchemaError, Self>;
-  readonly remove: (key: Key) => Effect.Effect<void, KvOperationError | S.SchemaError, Self>;
-  readonly unsafeRaw: () => Effect.Effect<KVNamespace, never, Self>;
 }
 
 const maybeString = (value: string | null | undefined): Option.Option<string> =>
@@ -311,51 +290,10 @@ export const Tag =
 
     const makeLayer = (binding: LayerOptions) => kvDefinition.layer(tag, binding);
 
-    const put = Effect.fnUntraced(function* (key: Key, value: Value, options?: KvPutOptions) {
-      const kv = yield* tag;
-      yield* kv.put(key, value, options);
-    });
-
-    const get = Effect.fnUntraced(function* (key: Key) {
-      const kv = yield* tag;
-      return yield* kv.get(key);
-    });
-
-    const getWithMetadata = Effect.fnUntraced(function* <Metadata>(
-      key: Key,
-      metadataSchema: S.Codec<Metadata, unknown>,
-    ) {
-      const kv = yield* tag;
-      return yield* kv.getWithMetadata(key, metadataSchema);
-    });
-
-    const list = Effect.fnUntraced(function* <Metadata = unknown>(
-      options?: KvListOptions<Metadata>,
-    ) {
-      const kv = yield* tag;
-      return yield* kv.list(options);
-    });
-
-    const remove = Effect.fnUntraced(function* (key: Key) {
-      const kv = yield* tag;
-      yield* kv.remove(key);
-    });
-
-    const unsafeRaw = Effect.fnUntraced(function* () {
-      const kv = yield* tag;
-      return yield* kv.unsafeRaw;
-    });
-
     return Object.assign(tag, {
       id: kvDefinition.id,
       keySchema: kvDefinition.key,
       valueSchema: kvDefinition.value,
       layer: makeLayer,
-      put,
-      get,
-      getWithMetadata,
-      list,
-      remove,
-      unsafeRaw,
     }) as TagClass<Self, Id, Key, Value, EncodedValue>;
   };