@restatedev/restate-sdk-gen 1.16.9 → 1.17.0

package/dist/index.d.cts

@@ -2,76 +2,7 @@ import * as restate from "@restatedev/restate-sdk";
 import { ContextDate, Opts, Rand, SendOpts, ServiceHandlerOpts } from "@restatedev/restate-sdk";
 
 //#region rolldown:runtime
-//#endregion
-//#region src/operation.d.ts
-interface Operation<T> {
-  [Symbol.iterator](): Iterator<unknown, T, unknown>;
-}
-declare function gen<T>(body: () => Generator<unknown, T, unknown>): Operation<T>;
-type SelectResult<B extends Record<string, Future<unknown>>> = { [K in keyof B]: {
-  tag: K;
-  future: B[K];
-} }[keyof B];
-declare function select<B extends Record<string, Future<unknown>>>(branches: B): Generator<unknown, SelectResult<B>, unknown>;
-//#endregion
-//#region src/future.d.ts
-declare const futureBrand: unique symbol;
-interface Future<T> extends Operation<T> {
-  readonly [futureBrand]: unknown;
-}
-/** Extract the value type from a `Future<U>`; `never` for non-Futures. */
-type FutureValue<F> = F extends Future<infer U> ? U : never;
-/**
- * Map a tuple of Futures to the tuple of their value types.
- * For `[Future<A>, Future<B>]` produces `[A, B]`.
- * For an unbounded `Future<X>[]` produces `X[]`.
- */
-type FutureValues<T extends readonly Future<unknown>[] | []> = { -readonly [P in keyof T]: T[P] extends Future<infer U> ? U : never };
-interface FutureFulfilledResult<T> {
-  readonly status: "fulfilled";
-  readonly value: T;
-}
-interface FutureRejectedResult {
-  readonly status: "rejected";
-  readonly reason: unknown;
-}
-type FutureSettledResult<T> = FutureFulfilledResult<T> | FutureRejectedResult;
-//#endregion
-//#region src/channel.d.ts
-interface Channel<T> {
-  /**
-   * Yieldable. Use as `yield* ch.send(value)` from within a gen body.
-   * The first call settles the channel; subsequent calls are silently
-   * dropped (idempotent).
-   *
-   * Return value is `Operation<void>` rather than `void` so the only
-   * way to fire send is via `yield*` inside a fiber — which enforces
-   * the channel-is-intra-workflow contract at the type level.
-   */
-  send(value: T): Operation<void>;
-  readonly receive: Future<T>;
-}
-//#endregion
-//#region src/invocation-reference.d.ts
-/** Synchronous handle for resolving or rejecting a signal on a target invocation */
-interface SignalReference<T> {
-  resolve(payload?: T): void;
-  reject(reason: string | restate.TerminalError): void;
-}
-/**
- * A typed reference to a running invocation. Returned by `sendClient()` methods
- * (wrapped in `Future<InvocationReference<O>>`), or created via `invocation(id)`.
- *
- * - `attach()` returns a `Future<O>` with the serde from the original descriptor.
- * - `signal()` sends a named signal to the target invocation.
- * - `cancel()` cancels the target invocation.
- */
-interface InvocationReference<O$1 = unknown> {
-  readonly id: string;
-  attach(serde?: restate.Serde<O$1>): Future<O$1>;
-  signal<T = unknown>(name: string, serde?: restate.Serde<T>): SignalReference<T>;
-  cancel(): void;
-}
+
 //#endregion
 //#region ../restate-sdk-core/src/core.d.ts
 type ServiceDefinition<P$1 extends string, M> = {
@@ -188,7 +119,7 @@ declare namespace StandardSchemaV1 {
  * It also advertises metadata (`contentType`, `jsonSchema`) that surfaces in
  * service discovery.
  */
-interface Serde<T> {
+interface Serde<T$1> {
   /**
    * MIME type of the bytes produced by `serialize` (and accepted by
    * `deserialize`).
@@ -252,12 +183,12 @@ interface Serde<T> {
      * The returned string must round-trip through `fromJsonString` back to
      * the same logical value.
      */
-    toJsonString(value: T): Promise<string> | string;
+    toJsonString(value: T$1): Promise<string> | string;
     /**
      * Parse a human-supplied JSON string back into a value of type `T`.
      * Should throw (or reject) if `json` is invalid for this serde.
      */
-    fromJsonString(json: string): Promise<T> | T;
+    fromJsonString(json: string): Promise<T$1> | T$1;
   };
   /**
    * Convert a value of type `T` into its on-the-wire bytes. This is the
@@ -266,22 +197,22 @@ interface Serde<T> {
    * Must be the inverse of `deserialize` — `deserialize(serialize(v))`
    * should produce a value equivalent to `v`.
    */
-  serialize(value: T): Uint8Array;
+  serialize(value: T$1): Uint8Array;
   /**
    * Convert on-the-wire bytes back into a value of type `T`. Must be the
    * inverse of `serialize`.
    *
    * May throw if `data` doesn't conform to the expected wire format.
    */
-  deserialize(data: Uint8Array): T;
+  deserialize(data: Uint8Array): T$1;
 }
 declare namespace serde {
-  class JsonSerde<T> implements Serde<T | undefined> {
+  class JsonSerde<T$1> implements Serde<T$1 | undefined> {
     readonly jsonSchema?: object | undefined;
     contentType: string;
     constructor(jsonSchema?: object | undefined);
-    serialize(value: T): Uint8Array;
-    deserialize(data: Uint8Array): T | undefined;
+    serialize(value: T$1): Uint8Array;
+    deserialize(data: Uint8Array): T$1 | undefined;
     schema<U$1>(schema: object): Serde<U$1>;
   }
   const json: JsonSerde<any>;
@@ -295,9 +226,9 @@ declare namespace serde {
    * @param jsonSchemaOptions options passed to `StandardJsonSchemaV1.Options.libraryOptions` for code generation
    * @returns a serde that will validate the data with the standard schema
    */
-  const schema: <T extends {
+  const schema: <T$1 extends {
     "~standard": StandardSchemaV1.Props;
-  }>(schema: T, validateOptions?: Record<string, unknown>, jsonSchemaOptions?: Record<string, unknown>) => Serde<StandardSchemaV1.InferOutput<T>>;
+  }>(schema: T$1, validateOptions?: Record<string, unknown>, jsonSchemaOptions?: Record<string, unknown>) => Serde<StandardSchemaV1.InferOutput<T$1>>;
 }
 //#endregion
 //#region ../restate-sdk-core/src/duration.d.ts
@@ -348,34 +279,137 @@ type JournalValueCodec = {
   decode(buf: Uint8Array): Promise<Uint8Array>;
 };
 //#endregion
-//#region src/define.d.ts
+//#region ../restate-sdk-core/src/interface.d.ts
 /**
- * Minimal descriptor stored in Descriptor._handlers per handler.
+ * Minimal descriptor stored in {@link Descriptor}._handlers per handler.
  */
-type HandlerDescriptor<I$1 = any, O$1 = any> = {
-  readonly _inputSerde?: restate.Serde<I$1>;
-  readonly _outputSerde?: restate.Serde<O$1>;
+type HandlerDescriptor<I$1 = any, O$1 = any, Shared extends boolean = boolean> = {
+  readonly _inputSerde?: Serde<I$1>;
+  readonly _outputSerde?: Serde<O$1>;
+  /** @internal virtual-object handler shared/exclusive marker (phantom + runtime) */
+  readonly _shared?: Shared;
 };
-/**
- * The single client-facing type for all definition styles.
- * - Returned by service() / object() / workflow() (also bindable to serve())
- * - Returned by restate.interface.service/object/workflow (pure, not bindable)
- * - Returned by implement() (also bindable)
- */
+/** Recover the input type declared by a {@link HandlerDescriptor}. */
+type InferInput<D> = D extends HandlerDescriptor<infer I, any, any> ? I : any;
+/** Recover the output type declared by a {@link HandlerDescriptor}. */
+type InferOutput<D> = D extends HandlerDescriptor<any, infer O, any> ? O : any;
+/** Recover the value type carried by a {@link Serde}. */
+type SerdeType<S$1> = S$1 extends Serde<infer T> ? T : never;
 type Descriptor<P$1 extends string = string, H extends Record<string, HandlerDescriptor> = Record<string, HandlerDescriptor>, Kind extends "service" | "object" | "workflow" = "service" | "object" | "workflow"> = {
   readonly name: P$1;
   readonly _kind: Kind;
   readonly _handlers: H;
 };
-/** Kind-specific aliases for the common Descriptor type */
 type ServiceDescriptor<P$1 extends string = string, H extends Record<string, HandlerDescriptor> = Record<string, HandlerDescriptor>> = Descriptor<P$1, H, "service">;
 type ObjectDescriptor<P$1 extends string = string, H extends Record<string, HandlerDescriptor> = Record<string, HandlerDescriptor>> = Descriptor<P$1, H, "object">;
 type WorkflowDescriptor<P$1 extends string = string, H extends Record<string, HandlerDescriptor> = Record<string, HandlerDescriptor>> = Descriptor<P$1, H, "workflow">;
-/** Implemented definition — extends Descriptor and also bindable to serve() */
-type ImplementedServiceDefinition<P$1 extends string, H extends Record<string, HandlerDescriptor>> = restate.ServiceDefinition<P$1, any> & ServiceDescriptor<P$1, H>;
-type ImplementedObjectDefinition<P$1 extends string, H extends Record<string, HandlerDescriptor>> = restate.VirtualObjectDefinition<P$1, any> & ObjectDescriptor<P$1, H>;
-type ImplementedWorkflowDefinition<P$1 extends string, H extends Record<string, HandlerDescriptor>> = restate.WorkflowDefinition<P$1, any> & WorkflowDescriptor<P$1, H>;
+/** Implemented definition — a Descriptor that is also bindable to an endpoint. */
+type ImplementedServiceDefinition<P$1 extends string, H extends Record<string, HandlerDescriptor>> = ServiceDefinition<P$1, any> & ServiceDescriptor<P$1, H>;
+type ImplementedObjectDefinition<P$1 extends string, H extends Record<string, HandlerDescriptor>> = VirtualObjectDefinition<P$1, any> & ObjectDescriptor<P$1, H>;
+type ImplementedWorkflowDefinition<P$1 extends string, H extends Record<string, HandlerDescriptor>> = WorkflowDefinition<P$1, any> & WorkflowDescriptor<P$1, H>;
 type ImplementedDefinition<P$1 extends string, H extends Record<string, HandlerDescriptor>, Kind extends "service" | "object" | "workflow"> = Kind extends "service" ? ImplementedServiceDefinition<P$1, H> : Kind extends "object" ? ImplementedObjectDefinition<P$1, H> : ImplementedWorkflowDefinition<P$1, H>;
+/** The shape of the {@link iface} service-interface declaration API. */
+interface ServiceInterface {
+  service<P$1 extends string, H extends Record<string, HandlerDescriptor>>(name: P$1, handlers: H): ServiceDescriptor<P$1, H>;
+  object<P$1 extends string, H extends Record<string, HandlerDescriptor>>(name: P$1, handlers: H): ObjectDescriptor<P$1, H>;
+  workflow<P$1 extends string, H extends Record<string, HandlerDescriptor>>(name: P$1, handlers: H): WorkflowDescriptor<P$1, H>;
+  /** `json<I, O>()` — type params, default JSON serde. */
+  json<I$1 = void, O$1 = void>(): HandlerDescriptor<I$1, O$1, false>;
+  /** `serdes({ input, output })` — explicit Serde per direction. */
+  serdes<SI extends Serde<any>, SO extends Serde<any>>(opts: {
+    input?: SI;
+    output?: SO;
+  }): HandlerDescriptor<SerdeType<SI>, SerdeType<SO>, false>;
+  /** `schemas({ input, output })` — Standard Schema per direction. */
+  schemas<SI extends StandardSchemaV1<any>, SO extends StandardSchemaV1<any>>(opts: {
+    input?: SI;
+    output?: SO;
+  }): HandlerDescriptor<StandardSchemaV1.InferOutput<NonNullable<SI>>, StandardSchemaV1.InferOutput<NonNullable<SO>>, false>;
+  /** Shared (read-only) virtual-object / non-`run` workflow handler declarators. */
+  shared: {
+    json<I$1 = void, O$1 = void>(): HandlerDescriptor<I$1, O$1, true>;
+    serdes<SI extends Serde<any>, SO extends Serde<any>>(opts: {
+      input?: SI;
+      output?: SO;
+    }): HandlerDescriptor<SerdeType<SI>, SerdeType<SO>, true>;
+    schemas<SI extends StandardSchemaV1<any>, SO extends StandardSchemaV1<any>>(opts: {
+      input?: SI;
+      output?: SO;
+    }): HandlerDescriptor<StandardSchemaV1.InferOutput<NonNullable<SI>>, StandardSchemaV1.InferOutput<NonNullable<SO>>, true>;
+  };
+}
+//#endregion
+//#region src/operation.d.ts
+interface Operation<T$1> {
+  [Symbol.iterator](): Iterator<unknown, T$1, unknown>;
+}
+declare function gen<T$1>(body: () => Generator<unknown, T$1, unknown>): Operation<T$1>;
+type SelectResult<B extends Record<string, Future<unknown>>> = { [K in keyof B]: {
+  tag: K;
+  future: B[K];
+} }[keyof B];
+declare function select<B extends Record<string, Future<unknown>>>(branches: B): Generator<unknown, SelectResult<B>, unknown>;
+//#endregion
+//#region src/future.d.ts
+declare const futureBrand: unique symbol;
+interface Future<T$1> extends Operation<T$1> {
+  readonly [futureBrand]: unknown;
+}
+/** Extract the value type from a `Future<U>`; `never` for non-Futures. */
+type FutureValue<F> = F extends Future<infer U> ? U : never;
+/**
+ * Map a tuple of Futures to the tuple of their value types.
+ * For `[Future<A>, Future<B>]` produces `[A, B]`.
+ * For an unbounded `Future<X>[]` produces `X[]`.
+ */
+type FutureValues<T$1 extends readonly Future<unknown>[] | []> = { -readonly [P in keyof T$1]: T$1[P] extends Future<infer U> ? U : never };
+interface FutureFulfilledResult<T$1> {
+  readonly status: "fulfilled";
+  readonly value: T$1;
+}
+interface FutureRejectedResult {
+  readonly status: "rejected";
+  readonly reason: unknown;
+}
+type FutureSettledResult<T$1> = FutureFulfilledResult<T$1> | FutureRejectedResult;
+//#endregion
+//#region src/channel.d.ts
+interface Channel<T$1> {
+  /**
+   * Yieldable. Use as `yield* ch.send(value)` from within a gen body.
+   * The first call settles the channel; subsequent calls are silently
+   * dropped (idempotent).
+   *
+   * Return value is `Operation<void>` rather than `void` so the only
+   * way to fire send is via `yield*` inside a fiber — which enforces
+   * the channel-is-intra-workflow contract at the type level.
+   */
+  send(value: T$1): Operation<void>;
+  readonly receive: Future<T$1>;
+}
+//#endregion
+//#region src/invocation-reference.d.ts
+/** Synchronous handle for resolving or rejecting a signal on a target invocation */
+interface SignalReference<T$1> {
+  resolve(payload?: T$1): void;
+  reject(reason: string | restate.TerminalError): void;
+}
+/**
+ * A typed reference to a running invocation. Returned by `sendClient()` methods
+ * (wrapped in `Future<InvocationReference<O>>`), or created via `invocation(id)`.
+ *
+ * - `attach()` returns a `Future<O>` with the serde from the original descriptor.
+ * - `signal()` sends a named signal to the target invocation.
+ * - `cancel()` cancels the target invocation.
+ */
+interface InvocationReference<O$1 = unknown> {
+  readonly id: string;
+  attach(serde?: restate.Serde<O$1>): Future<O$1>;
+  signal<T$1 = unknown>(name: string, serde?: restate.Serde<T$1>): SignalReference<T$1>;
+  cancel(): void;
+}
+//#endregion
+//#region src/define.d.ts
 /** @internal
  * @internal - Wraps a generator function with optional serde. Produced by typed().
  * Discriminated by _genFn for runtime detection (distinct from bare gen fns,
@@ -472,18 +506,18 @@ type GenSendClient<H extends Record<string, HandlerDescriptor>> = { readonly [K
 //#endregion
 //#region src/durable-promise.d.ts
 /** Same shape as the SDK's DurablePromise<T> but each method returns Future<...>. */
-type GenDurablePromise<T> = {
-  peek(): Future<T | undefined>;
-  resolve(value?: T): Future<void>;
+type GenDurablePromise<T$1> = {
+  peek(): Future<T$1 | undefined>;
+  resolve(value?: T$1): Future<void>;
   reject(errorMsg: string): Future<void>;
-  get(): Future<T>;
+  get(): Future<T$1>;
 };
 //#endregion
 //#region src/task.d.ts
 /**
  * A handle to a spawned routine: its `Future<T>` plus `interrupt`.
  */
-interface Task<T> extends Future<T> {
+interface Task<T$1> extends Future<T$1> {
   /**
    * Throw `err` into the spawned routine at its next yield point, and
    * abort its in-flight `run` I/O. `err` is delivered verbatim — the
@@ -621,13 +655,13 @@ type RetryOptions = {
  * for arrow functions assigned to a `const` since JS infers names from
  * the binding site). If neither resolves, `run` throws.
  */
-type RunOpts<T> = {
+type RunOpts<T$1> = {
   /** Journal entry name. Falls back to `action.name` if absent. */
   name?: string;
   /** Retry policy. Defaults to the SDK's defaults if absent. */
   retry?: RetryOptions;
   /** Custom serde for the journaled value. */
-  serde?: restate.Serde<T>;
+  serde?: restate.Serde<T$1>;
 };
 /**
  * Options object passed to the closure of `run(...)`. Carries an
@@ -645,7 +679,7 @@ type RunActionOpts = {
  * signal into AbortSignal-aware APIs (e.g. `fetch(url, { signal })`)
  * to cancel in-flight syscalls promptly.
  */
-type RunAction<T> = (opts: RunActionOpts) => Promise<T>;
+type RunAction<T$1> = (opts: RunActionOpts) => Promise<T$1>;
 /**
  * Wrap a user-supplied `run` closure to surface the abort reason
  * (typically a TerminalError(CANCELLED)) on throw paths if the signal
@@ -662,7 +696,7 @@ type RunAction<T> = (opts: RunActionOpts) => Promise<T>;
  * Exposed for testing — the wrapper's behavior is the part that has
  * semantic bite, separate from the ctx.run plumbing.
  */
-declare function wrapActionForCancellation<T>(signal: AbortSignal, action: RunAction<T>): () => Promise<T>;
+declare function wrapActionForCancellation<T$1>(signal: AbortSignal, action: RunAction<T$1>): () => Promise<T$1>;
 /**
  * Deterministic date methods that return journal-backed Futures.
  * Wraps the SDK's `ContextDate` (which returns Promises via internal
@@ -714,7 +748,7 @@ type ExecuteOptions = SchedulerOptions;
  *     return greeting;
  *   }));
  */
-declare function execute<T>(context: restate.Context, op: Operation<T>, options?: ExecuteOptions): Promise<T>;
+declare function execute<T$1>(context: restate.Context, op: Operation<T$1>, options?: ExecuteOptions): Promise<T$1>;
 //#endregion
 //#region src/free.d.ts
 declare const rand: () => restate.Rand;
@@ -734,16 +768,16 @@ declare const handlerRequest: () => HandlerRequest;
  * arrow functions assigned to a `const`) or specified explicitly via
  * `opts.name`. If neither resolves, throws.
  */
-declare const run: <T>(action: RunAction<T>, opts?: RunOpts<T>) => Future<T>;
+declare const run: <T$1>(action: RunAction<T$1>, opts?: RunOpts<T$1>) => Future<T$1>;
 declare const sleep: (duration: restate.Duration | number, name?: string) => Future<void>;
-declare const awakeable: <T>(serde?: restate.Serde<T>) => {
+declare const awakeable: <T$1>(serde?: restate.Serde<T$1>) => {
   id: string;
-  promise: Future<T>;
+  promise: Future<T$1>;
 };
-declare const resolveAwakeable: <T>(id: string, payload?: T, serde?: restate.Serde<T>) => void;
+declare const resolveAwakeable: <T$1>(id: string, payload?: T$1, serde?: restate.Serde<T$1>) => void;
 declare const rejectAwakeable: (id: string, reason: string | restate.TerminalError) => void;
-declare const signal: <T>(name: string, serde?: restate.Serde<T>) => Future<T>;
-declare const attach: <T>(invocationId: restate.InvocationId, serde?: restate.Serde<T>) => Future<T>;
+declare const signal: <T$1>(name: string, serde?: restate.Serde<T$1>) => Future<T$1>;
+declare const attach: <T$1>(invocationId: restate.InvocationId, serde?: restate.Serde<T$1>) => Future<T$1>;
 declare function client<H extends Record<string, HandlerDescriptor>>(def: Descriptor<string, H, "service">): GenClient<H>;
 declare function client<H extends Record<string, HandlerDescriptor>>(def: Descriptor<string, H, "object" | "workflow">, key: string): GenClient<H>;
 declare function sendClient<H extends Record<string, HandlerDescriptor>>(def: Descriptor<string, H, "service">): GenSendClient<H>;
@@ -769,36 +803,36 @@ declare function invocation<O$1 = unknown>(id: string, opts?: {
   outputSerde?: restate.Serde<O$1>;
 }): InvocationReference<O$1>;
 declare const cancel: (invocationId: restate.InvocationId) => void;
-declare const channel: <T>() => Channel<T>;
+declare const channel: <T$1>() => Channel<T$1>;
 declare const state: <TState extends TypedState = UntypedState>() => State<TState>;
 declare const sharedState: <TState extends TypedState = UntypedState>() => SharedState<TState>;
-declare const workflowPromise: <T>(name: string, serde?: restate.Serde<T>) => GenDurablePromise<T>;
+declare const workflowPromise: <T$1>(name: string, serde?: restate.Serde<T$1>) => GenDurablePromise<T$1>;
 /**
  * Wait for every future to settle; return their values in input order.
  * Heterogeneous-tuple typing — `all([fA, fB])` where `fA: Future<A>`
  * and `fB: Future<B>` yields `Future<[A, B]>`. Mirrors `Promise.all`.
  */
-declare const all: <const T extends readonly Future<unknown>[] | []>(futures: T) => Future<FutureValues<T>>;
+declare const all: <const T$1 extends readonly Future<unknown>[] | []>(futures: T$1) => Future<FutureValues<T$1>>;
 /**
  * Return the first future to settle; losers continue running (until
  * the main operation settles — see `OnMainExit`) but their results are
  * discarded. Heterogeneous-tuple typing — `race([fA, fB])` yields
  * `Future<A | B>`. Mirrors `Promise.race`.
  */
-declare const race: <const T extends readonly Future<unknown>[] | []>(futures: T) => Future<FutureValues<T>[number]>;
+declare const race: <const T$1 extends readonly Future<unknown>[] | []>(futures: T$1) => Future<FutureValues<T$1>[number]>;
 /**
  * First-to-succeed wins (non-rejected). Rejects with `AggregateError(errors)`
  * when every input rejects (including the empty input case). Tuple-aware —
  * `any([fA, fB])` yields `Future<A | B>`. Mirrors `Promise.any`.
  */
-declare const any: <const T extends readonly Future<unknown>[] | []>(futures: T) => Future<FutureValues<T>[number]>;
+declare const any: <const T$1 extends readonly Future<unknown>[] | []>(futures: T$1) => Future<FutureValues<T$1>[number]>;
 /**
  * Wait for every future to settle; never rejects. Tuple-aware —
  * `allSettled([fA, fB])` yields
  * `Future<[FutureSettledResult<A>, FutureSettledResult<B>]>`.
  * Mirrors `Promise.allSettled`.
  */
-declare const allSettled: <const T extends readonly Future<unknown>[] | []>(futures: T) => Future<{ -readonly [P in keyof T]: FutureSettledResult<T[P] extends Future<infer U> ? U : never> }>;
+declare const allSettled: <const T$1 extends readonly Future<unknown>[] | []>(futures: T$1) => Future<{ -readonly [P in keyof T$1]: FutureSettledResult<T$1[P] extends Future<infer U> ? U : never> }>;
 /**
  * Register `op` as a fresh routine and return a `Task<T>` for its
  * eventual outcome — a `Future<T>` plus `interrupt(err?)` to throw into
@@ -807,7 +841,7 @@ declare const allSettled: <const T extends readonly Future<unknown>[] | []>(futu
  * when the main operation settles is abandoned by default (see
  * `OnMainExit`). See `RestateOperations.spawn` for full semantics.
  */
-declare const spawn: <T>(op: Operation<T>) => Task<T>;
+declare const spawn: <T$1>(op: Operation<T$1>) => Task<T$1>;
 //#endregion
 //#region src/context.d.ts
 /**
@@ -815,7 +849,7 @@ declare const spawn: <T>(op: Operation<T>) => Task<T>;
  * {@link contextLocal} (at module scope is fine — minting touches no
  * fiber), then `get`/`set` it from inside the workflow body.
  */
-interface ContextLocal<T> {
+interface ContextLocal<T$1> {
   /**
    * Read this slot's value for the current invocation. Returns the
    * value previously {@link set} during this invocation, or the default
@@ -824,14 +858,14 @@ interface ContextLocal<T> {
    * synchronous span (a `gen` body running under `execute`); calling it
    * from an `ops.run` closure or other async callback throws.
    */
-  get: () => T;
+  get: () => T$1;
   /**
    * Set this slot's value for the rest of the current invocation,
    * visible to every fiber under it. Must be called from generator code
    * on the fiber's synchronous span; calling it from an `ops.run`
    * closure or other async callback throws.
    */
-  set: (value: T) => void;
+  set: (value: T$1) => void;
 }
 /**
  * Create a context-local storage slot.
@@ -855,30 +889,10 @@ interface ContextLocal<T> {
  *   const traceId = contextLocal<string>();      // ContextLocal<string | undefined>
  *   const t = traceId.get();                       // string | undefined
  */
-declare function contextLocal<T>(defaultValue: T): ContextLocal<T>;
-declare function contextLocal<T>(): ContextLocal<T | undefined>;
-declare namespace interface_d_exports {
-  export { ImplementHandlers, InferInput, InferOutput, implement, json, object$1 as object, schemas$1 as schemas, serdes$1 as serdes, service$1 as service, workflow$1 as workflow };
-}
-/** json<I, O>() — type params, default JSON serde */
-declare function json<I$1 = void, O$1 = void>(): HandlerDescriptor<I$1, O$1>;
-/** serdes(opts) — explicit Serde per field */
-declare function serdes$1<SI extends restate.Serde<any>, SO extends restate.Serde<any>>(opts: {
-  input?: SI;
-  output?: SO;
-}): HandlerDescriptor<SI extends restate.Serde<infer I> ? I : never, SO extends restate.Serde<infer O> ? O : never>;
-/** schemas(opts) — Standard Schema (Zod, TypeBox, Valibot, …) per field */
-declare function schemas$1<SI extends StandardSchemaV1<any>, SO extends StandardSchemaV1<any>>(opts: {
-  input?: SI;
-  output?: SO;
-}): HandlerDescriptor<StandardSchemaV1.InferOutput<NonNullable<SI>>, StandardSchemaV1.InferOutput<NonNullable<SO>>>;
-declare function service$1<P$1 extends string, H extends Record<string, HandlerDescriptor>>(name: P$1, handlers: H): ServiceDescriptor<P$1, H>;
-declare function object$1<P$1 extends string, H extends Record<string, HandlerDescriptor>>(name: P$1, handlers: H): ObjectDescriptor<P$1, H>;
-declare function workflow$1<P$1 extends string, H extends Record<string, HandlerDescriptor>>(name: P$1, handlers: H): WorkflowDescriptor<P$1, H>;
-/** @internal */
-type InferInput<D> = D extends HandlerDescriptor<infer I, any> ? I : any;
-/** @internal */
-type InferOutput<D> = D extends HandlerDescriptor<any, infer O> ? O : any;
+declare function contextLocal<T$1>(defaultValue: T$1): ContextLocal<T$1>;
+declare function contextLocal<T$1>(): ContextLocal<T$1 | undefined>;
+//#endregion
+//#region src/interface.d.ts
 /** @internal */
 type ImplementHandlers<H extends Record<string, HandlerDescriptor>> = { [K in keyof H]: (input: InferInput<H[K]>) => Operation<InferOutput<H[K]>> };
 declare function implement<P$1 extends string, H extends Record<string, HandlerDescriptor>>(iface: ServiceDescriptor<P$1, H>, config: {
@@ -927,17 +941,39 @@ interface Ingress {
    */
   objectClient<D>(opts: VirtualObjectDefinitionFrom<D>, key: string): IngressClient<VirtualObject<D>>;
   /**
-   * Create a client from a {@link ServiceDefinition}.
+   * Create a send client from a {@link ServiceDefinition}.
    */
   serviceSendClient<D>(opts: ServiceDefinitionFrom<D>): IngressSendClient<Service<D>>;
   /**
-   * Create a client from a {@link VirtualObjectDefinition}.
+   * Create a send client from a {@link VirtualObjectDefinition}.
    */
   objectSendClient<D>(opts: VirtualObjectDefinitionFrom<D>, key: string): IngressSendClient<VirtualObject<D>>;
+  /**
+   * Create a request/response client from a service interface / `Descriptor`.
+   *
+   * @example
+   * ```ts
+   * ingress.client(greeter).greet(req);      // service
+   * ingress.client(counter, "k").add(1);     // virtual object / workflow
+   * ```
+   */
+  client<P$1 extends string, H extends Record<string, HandlerDescriptor>>(serviceInterface: ServiceDescriptor<P$1, H>): IngressClientFromDescriptors<H>;
+  client<P$1 extends string, H extends Record<string, HandlerDescriptor>>(objectOrWorkflowInterface: ObjectDescriptor<P$1, H> | WorkflowDescriptor<P$1, H>, key: string): IngressClientFromDescriptors<H>;
+  /**
+   * Send-client (one-way) counterpart of {@link Ingress.client}.
+   *
+   * @example
+   * ```ts
+   * ingress.sendClient(greeter).greet(req);
+   * ingress.sendClient(counter, "k").add(1);
+   * ```
+   */
+  sendClient<P$1 extends string, H extends Record<string, HandlerDescriptor>>(serviceInterface: ServiceDescriptor<P$1, H>): IngressSendClientFromDescriptors<H>;
+  sendClient<P$1 extends string, H extends Record<string, HandlerDescriptor>>(objectOrWorkflowInterface: ObjectDescriptor<P$1, H> | WorkflowDescriptor<P$1, H>, key: string): IngressSendClientFromDescriptors<H>;
   /**
    * Resolve an awakeable from the ingress client.
    */
-  resolveAwakeable<T>(id: string, payload?: T, payloadSerde?: Serde<T>): Promise<void>;
+  resolveAwakeable<T$1>(id: string, payload?: T$1, payloadSerde?: Serde<T$1>): Promise<void>;
   /**
    * Reject an awakeable from the ingress client.
    */
@@ -947,7 +983,7 @@ interface Ingress {
    *
    * @param send either the send response or the workflow submission as obtained by the respective clients.
    */
-  result<T>(send: Send<T> | WorkflowSubmission<T>, resultSerde?: Serde<T>): Promise<T>;
+  result<T$1>(send: Send<T$1> | WorkflowSubmission<T$1>, resultSerde?: Serde<T$1>): Promise<T$1>;
   /** Generic request-response call. Routes directly by service name without a typed definition. */
   call<I$1 = Uint8Array, O$1 = Uint8Array>(opts: {
     service: string;
@@ -1040,7 +1076,7 @@ interface Ingress {
  * @experimental
  * @interface
  */
-type ScopedIngress = Pick<Ingress, "serviceClient" | "serviceSendClient" | "objectClient" | "objectSendClient" | "workflowClient">;
+type ScopedIngress = Pick<Ingress, "serviceClient" | "serviceSendClient" | "objectClient" | "objectSendClient" | "workflowClient" | "client" | "sendClient">;
 interface IngressCallOptions<I$1 = unknown, O$1 = unknown> {
   /**
    * Key to use for idempotency key.
@@ -1117,6 +1153,15 @@ declare class SendOpts$1<I$1 = unknown> {
 }
 type InferArgType<P$1> = P$1 extends [infer A, ...any[]] ? A : unknown;
 type IngressClient<M> = { [K in keyof M as M[K] extends never ? never : K]: M[K] extends ((arg: any, ...args: infer P) => PromiseLike<infer O>) ? (...args: [...P, ...[opts?: Opts$1<InferArgType<P>, O>]]) => PromiseLike<O> : never };
+/**
+ * Typed ingress request/response client derived from a service interface's
+ * handler descriptor map `H` (see `iface` in `@restatedev/restate-sdk-core`).
+ * Recovers the input/output types directly from the descriptors, so a code-free
+ * interface value produces a fully typed client that reuses the declared serdes.
+ */
+type IngressClientFromDescriptors<H extends Record<string, HandlerDescriptor>> = { readonly [K in keyof H]: [InferInput<H[K]>] extends [void] ? (opts?: Opts$1<InferInput<H[K]>, InferOutput<H[K]>>) => Promise<InferOutput<H[K]>> : (input: InferInput<H[K]>, opts?: Opts$1<InferInput<H[K]>, InferOutput<H[K]>>) => Promise<InferOutput<H[K]>> };
+/** One-way (send) counterpart of {@link IngressClientFromDescriptors}. */
+type IngressSendClientFromDescriptors<H extends Record<string, HandlerDescriptor>> = { readonly [K in keyof H]: [InferInput<H[K]>] extends [void] ? (opts?: SendOpts$1<InferInput<H[K]>>) => Promise<Send<InferOutput<H[K]>>> : (input: InferInput<H[K]>, opts?: SendOpts$1<InferInput<H[K]>>) => Promise<Send<InferOutput<H[K]>>> };
 /**
  * Represents the output of a workflow.
  */
@@ -1134,7 +1179,7 @@ interface Output<O$1> {
  * Represents a successful workflow submission.
  *
  */
-type WorkflowSubmission<T> = {
+type WorkflowSubmission<T$1> = {
   /**
    * The invocation id of the workflow. You can use that id to
    * with the introspection tools (restate cli, logging, metrics)
@@ -1210,7 +1255,7 @@ type IngressWorkflowClient<M> = Omit<{ [K in keyof M as M[K] extends never ? nev
  *
  * @typeParam T the type of the response.
  */
-type Send<T = unknown> = {
+type Send<T$1 = unknown> = {
   /**
    * The invocation id of the send.
    */
@@ -1404,32 +1449,46 @@ declare namespace ingress_d_exports {
   export { ConnectionOpts, GenIngress, HttpCallError, Ingress, IngressClient, IngressHandlerClient, IngressSendClient, IngressSendHandlerClient, IngressWorkflowClient, Opts$1 as Opts, RetryFailure, RetryPolicy, ScopedGenIngress, Send, SendOpts$1 as SendOpts, client$1 as client, connect, defaultShouldRetry, scope$1 as scope, sendClient$1 as sendClient };
 }
 /**
- * Connect to the Restate Ingress.
- *
- * @param opts connection options
- * @returns a connection the the restate ingress
+ * @deprecated Use `connect` from `@restatedev/restate-sdk-clients` and its typed
+ * client methods, e.g. `connect({ url }).serviceClient(def)`
  */
 declare function connect(opts: ConnectionOpts): GenIngress;
 /**
- * Minimal ingress interface required by the sdk-gen ingress helpers.
- * Structurally compatible with `Ingress` from `@restatedev/restate-sdk-clients`
- * — any object returned by `connect()` satisfies this.
+ * @deprecated Use `connect` from `@restatedev/restate-sdk-clients` and its typed
+ * client methods, e.g. `connect({ url }).serviceClient(def)`
  */
-type GenIngress = Omit<Ingress, "serviceClient" | "serviceSendClient" | "objectClient" | "objectSendClient" | "workflowClient">;
+type GenIngress = Ingress;
 type InferInput$1<D> = D extends HandlerDescriptor<infer I, any> ? I : unknown;
 type InferOutput$1<D> = D extends HandlerDescriptor<any, infer O> ? O : unknown;
-/** Typed ingress call client — each method returns Promise<O> */
+/**
+ * Typed ingress call client — each method returns Promise<O>.
+ *
+ * @deprecated Use the client returned by `ingress.serviceClient(def)` /
+ * `ingress.objectClient(def, key)` from `@restatedev/restate-sdk-clients`.
+ */
 type IngressHandlerClient<H extends Record<string, HandlerDescriptor>> = { readonly [K in keyof H]: (input: InferInput$1<H[K]>, opts?: Opts$1<InferInput$1<H[K]>, InferOutput$1<H[K]>>) => Promise<InferOutput$1<H[K]>> };
-/** Typed ingress send client — each method returns Promise<Send> */
+/**
+ * Typed ingress send client — each method returns Promise<Send>.
+ *
+ * @deprecated Use the client returned by `ingress.serviceSendClient(def)` /
+ * `ingress.objectSendClient(def, key)` from `@restatedev/restate-sdk-clients`.
+ */
 type IngressSendHandlerClient<H extends Record<string, HandlerDescriptor>> = { readonly [K in keyof H]: [InferInput$1<H[K]>] extends [void] ? (opts?: SendOpts$1<void>) => Promise<Send> : (input: InferInput$1<H[K]>, opts?: SendOpts$1<InferInput$1<H[K]>>) => Promise<Send> };
+/**
+ * @deprecated Call the regular ingress client directly: `ingress.client(def)`
+ * for a service, or `ingress.client(def, key)` for a virtual object / workflow.
+ */
 declare function client$1<H extends Record<string, HandlerDescriptor>>(ingress: GenIngress, def: Descriptor<string, H, "service">): IngressHandlerClient<H>;
 declare function client$1<H extends Record<string, HandlerDescriptor>>(ingress: GenIngress, def: Descriptor<string, H, "object" | "workflow">, key: string): IngressHandlerClient<H>;
+/**
+ * @deprecated Call the regular ingress client directly: `ingress.sendClient(def)`
+ * for a service, or `ingress.sendClient(def, key)` for a virtual object / workflow.
+ */
 declare function sendClient$1<H extends Record<string, HandlerDescriptor>>(ingress: GenIngress, def: Descriptor<string, H, "service">): IngressSendHandlerClient<H>;
 declare function sendClient$1<H extends Record<string, HandlerDescriptor>>(ingress: GenIngress, def: Descriptor<string, H, "object" | "workflow">, key: string): IngressSendHandlerClient<H>;
 /**
- * Ingress client bundle bound to a specific scope, returned by {@link scope}.
- * Mirrors the in-handler `scope(...)` surface: same `client`/`sendClient`
- * overloads, but every call/send routes within the bound scope.
+ * @deprecated Use `ingress.scope(scopeKey)` from
+ * `@restatedev/restate-sdk-clients` and its `client`/`sendClient` methods.
  */
 interface ScopedGenIngress {
   client<H extends Record<string, HandlerDescriptor>>(def: Descriptor<string, H, "service">): IngressHandlerClient<H>;
@@ -1438,14 +1497,9 @@ interface ScopedGenIngress {
   sendClient<H extends Record<string, HandlerDescriptor>>(def: Descriptor<string, H, "object" | "workflow">, key: string): IngressSendHandlerClient<H>;
 }
 /**
- * Route all ingress calls/sends through a named scope. The in-handler
- * `scope(scopeKey)` and this `scope(ingress, scopeKey)` produce the same
- * `.client(def)` / `.sendClient(def)` shape, so handler and ingress code
- * read identically (modulo the explicit `ingress`).
- *
- * @example
- *   await clients.scope(ingress, "tenant-123").client(Greeter).greet(name);
- *   await clients.scope(ingress, "tenant-123").client(Cart, "cart-42").add(item);
+ * @deprecated Use `ingress.scope(scopeKey)` from
+ * `@restatedev/restate-sdk-clients`, then `.client(def)` / `.sendClient(def)`
+ * on the returned scoped ingress.
  */
 declare function scope$1(ingress: GenIngress, scopeKey: string): ScopedGenIngress;
 declare namespace internal_operations_d_exports {
@@ -1469,5 +1523,33 @@ declare namespace internal_operations_d_exports {
  */
 declare function isProcessing(): boolean | undefined;
 //#endregion
-export { type AnyGenFn, type Channel, type ClientFuture, type ContextDate, type ContextLocal, type Descriptor, type Duration, type EntryToDescriptor, type ExecuteOptions, type Future, type FutureFulfilledResult, type FutureRejectedResult, type FutureSettledResult, type FutureValue, type FutureValues, type GenClient, type GenContextDate, type GenDurablePromise, type GenHandlerOpts, type GenObjectHandlerOpts, type GenSendClient, type GenWorkflowHandlerOpts, type HandlerDef, type HandlerDescriptor, type HandlerDescriptors, type HandlerOrHandlerDescriptor, type HandlerRequest, type ImplementHandlers, type ImplementedDefinition, type ImplementedObjectDefinition, type ImplementedServiceDefinition, type ImplementedWorkflowDefinition, type InferInput, type InferOutput, InterruptedError, type InvocationReference, type ObjectDescriptor, type OnMainExit, type Operation, type Rand, type RetryOptions, type RunAction, type RunActionOpts, type RunOpts, type SchedulerOptions, type ScopedOperations, type SelectResult, type Serde, type Service, type ServiceDefinition, type ServiceDefinitionFrom, type ServiceDescriptor, type SharedState, type SignalReference, type StandardSchemaV1, type StandardTypedV1, type State, type Task, type TypedState, type UntypedState, type VirtualObject, type VirtualObjectDefinition, type VirtualObjectDefinitionFrom, type Workflow, type WorkflowDefinition, type WorkflowDefinitionFrom, type WorkflowDescriptor, all, allSettled, any, attach, awakeable, call, cancel, channel, client, ingress_d_exports as clients, contextLocal, date, execute, gen, handlerRequest, interface_d_exports as iface, implement, internal_operations_d_exports as internal, invocation, logger, object, race, rand, rejectAwakeable, resolveAwakeable, run, schemas, scope, select, send, sendClient, serde, serdes, service, sharedState, signal, sleep, spawn, state, workflow, workflowPromise, wrapActionForCancellation };
+//#region src/index.d.ts
+declare const iface: {
+  implement: typeof implement;
+  service<P$1 extends string, H extends Record<string, HandlerDescriptor>>(name: P$1, handlers: H): ServiceDescriptor<P$1, H>;
+  object<P$1 extends string, H extends Record<string, HandlerDescriptor>>(name: P$1, handlers: H): ObjectDescriptor<P$1, H>;
+  workflow<P$1 extends string, H extends Record<string, HandlerDescriptor>>(name: P$1, handlers: H): WorkflowDescriptor<P$1, H>;
+  json<I$1 = void, O$1 = void>(): HandlerDescriptor<I$1, O$1, false>;
+  serdes<SI extends Serde<any>, SO extends Serde<any>>(opts: {
+    input?: SI;
+    output?: SO;
+  }): HandlerDescriptor<SerdeType<SI>, SerdeType<SO>, false>;
+  schemas<SI extends StandardSchemaV1<any>, SO extends StandardSchemaV1<any>>(opts: {
+    input?: SI;
+    output?: SO;
+  }): HandlerDescriptor<StandardSchemaV1.InferOutput<NonNullable<SI>>, StandardSchemaV1.InferOutput<NonNullable<SO>>, false>;
+  shared: {
+    json<I$1 = void, O$1 = void>(): HandlerDescriptor<I$1, O$1, true>;
+    serdes<SI extends Serde<any>, SO extends Serde<any>>(opts: {
+      input?: SI;
+      output?: SO;
+    }): HandlerDescriptor<SerdeType<SI>, SerdeType<SO>, true>;
+    schemas<SI extends StandardSchemaV1<any>, SO extends StandardSchemaV1<any>>(opts: {
+      input?: SI;
+      output?: SO;
+    }): HandlerDescriptor<StandardSchemaV1.InferOutput<NonNullable<SI>>, StandardSchemaV1.InferOutput<NonNullable<SO>>, true>;
+  };
+};
+//#endregion
+export { type AnyGenFn, type Channel, type ClientFuture, type ContextDate, type ContextLocal, type Descriptor, type Duration, type EntryToDescriptor, type ExecuteOptions, type Future, type FutureFulfilledResult, type FutureRejectedResult, type FutureSettledResult, type FutureValue, type FutureValues, type GenClient, type GenContextDate, type GenDurablePromise, type GenHandlerOpts, type GenObjectHandlerOpts, type GenSendClient, type GenWorkflowHandlerOpts, type HandlerDef, type HandlerDescriptor, type HandlerDescriptors, type HandlerOrHandlerDescriptor, type HandlerRequest, type ImplementHandlers, type ImplementedDefinition, type ImplementedObjectDefinition, type ImplementedServiceDefinition, type ImplementedWorkflowDefinition, type InferInput, type InferOutput, InterruptedError, type InvocationReference, type ObjectDescriptor, type OnMainExit, type Operation, type Rand, type RetryOptions, type RunAction, type RunActionOpts, type RunOpts, type SchedulerOptions, type ScopedOperations, type SelectResult, type Serde, type SerdeType, type Service, type ServiceDefinition, type ServiceDefinitionFrom, type ServiceDescriptor, type ServiceInterface, type SharedState, type SignalReference, type StandardSchemaV1, type StandardTypedV1, type State, type Task, type TypedState, type UntypedState, type VirtualObject, type VirtualObjectDefinition, type VirtualObjectDefinitionFrom, type Workflow, type WorkflowDefinition, type WorkflowDefinitionFrom, type WorkflowDescriptor, all, allSettled, any, attach, awakeable, call, cancel, channel, client, ingress_d_exports as clients, contextLocal, date, execute, gen, handlerRequest, iface, implement, internal_operations_d_exports as internal, invocation, logger, object, race, rand, rejectAwakeable, resolveAwakeable, run, schemas, scope, select, send, sendClient, serde, serdes, service, sharedState, signal, sleep, spawn, state, workflow, workflowPromise, wrapActionForCancellation };
 //# sourceMappingURL=index.d.cts.map