@qlever-llc/trellis 0.10.22 → 0.11.0-rc.1

package/src/sdk/_generated/auth/client.ts

@@ -15,13 +15,11 @@ import type {
   OperationRef,
   OperationRefData,
   OperationRuntimeHandle,
-  OperationTransferHandle,
   PreparedTrellisEvent,
   ReceiveTransferGrant,
   ReceiveTransferHandle,
   RequestOpts,
   Result,
-  RpcHandlerContext,
   SendTransferGrant,
   SendTransferHandle,
   TerminalOperation,
@@ -33,8 +31,7 @@ import type {
 } from "../../../index.js";
 import type { API, Api } from "./api.js";
 import type * as Types from "./types.js";
-
-type WithDeps<TDeps> = [TDeps] extends [undefined] ? {} : { deps: TDeps };
+import type * as HealthSdk from "../health/mod.js";
 
 type EventCallback<TMessage> = {
   bivarianceHack(
@@ -43,46 +40,10 @@ type EventCallback<TMessage> = {
   ): MaybeAsync<void, BaseError>;
 }["bivarianceHack"];
 
-type ServiceEventHandler<TEvent, TDeps = undefined> = (
-  args:
-    & { event: TEvent; context: EventListenerContext; client: HandlerClient }
-    & WithDeps<TDeps>,
+type DependencyServiceEventHandler<TEvent> = (
+  args: { event: TEvent; context: EventListenerContext; client: HandlerClient },
 ) => MaybeAsync<void, BaseError>;
 
-type RpcHandler<TInput, TOutput, TDeps = undefined> = (
-  args:
-    & { input: TInput; context: RpcHandlerContext; client: HandlerClient }
-    & WithDeps<TDeps>,
-) => MaybeAsync<TOutput, BaseError>;
-
-type FeedHandler<TInput, TEvent, TDeps = undefined> = (
-  context: {
-    input: TInput;
-    caller: unknown;
-    signal: AbortSignal;
-    emit(event: TEvent): AsyncResult<void, ValidationError | UnexpectedError>;
-    client: HandlerClient;
-  } & WithDeps<TDeps>,
-) => unknown | Promise<unknown>;
-
-type OperationHandler<
-  TInput,
-  TProgress,
-  TOutput,
-  TTransfer,
-  TDeps = undefined,
-> = (
-  context:
-    & {
-      input: TInput;
-      op: OperationRuntimeHandle<TProgress, TOutput>;
-      caller: unknown;
-      client: HandlerClient;
-    }
-    & TTransfer
-    & WithDeps<TDeps>,
-) => unknown | Promise<unknown>;
-
 export type TrellisAuthState = {};
 
 type AuthDeviceUserAuthoritiesResolveOperationDesc =
@@ -416,14 +377,12 @@ export interface TrellisAuthClient {
     readonly auth: {
       connectionsClosed: {
         publish(
-          event: Omit<Types.AuthConnectionsClosedEvent, "header">,
+          event: Types.AuthConnectionsClosedEvent,
         ): AsyncResult<void, ValidationError | UnexpectedError>;
         prepare(
-          event: Omit<Types.AuthConnectionsClosedEvent, "header">,
+          event: Types.AuthConnectionsClosedEvent,
         ): Result<
-          PreparedTrellisEvent<
-            Omit<Types.AuthConnectionsClosedEvent, "header">
-          >,
+          PreparedTrellisEvent<Types.AuthConnectionsClosedEvent>,
           ValidationError | UnexpectedError
         >;
         listen(
@@ -434,14 +393,12 @@ export interface TrellisAuthClient {
       };
       connectionsKicked: {
         publish(
-          event: Omit<Types.AuthConnectionsKickedEvent, "header">,
+          event: Types.AuthConnectionsKickedEvent,
         ): AsyncResult<void, ValidationError | UnexpectedError>;
         prepare(
-          event: Omit<Types.AuthConnectionsKickedEvent, "header">,
+          event: Types.AuthConnectionsKickedEvent,
         ): Result<
-          PreparedTrellisEvent<
-            Omit<Types.AuthConnectionsKickedEvent, "header">
-          >,
+          PreparedTrellisEvent<Types.AuthConnectionsKickedEvent>,
           ValidationError | UnexpectedError
         >;
         listen(
@@ -452,14 +409,12 @@ export interface TrellisAuthClient {
       };
       connectionsOpened: {
         publish(
-          event: Omit<Types.AuthConnectionsOpenedEvent, "header">,
+          event: Types.AuthConnectionsOpenedEvent,
         ): AsyncResult<void, ValidationError | UnexpectedError>;
         prepare(
-          event: Omit<Types.AuthConnectionsOpenedEvent, "header">,
+          event: Types.AuthConnectionsOpenedEvent,
         ): Result<
-          PreparedTrellisEvent<
-            Omit<Types.AuthConnectionsOpenedEvent, "header">
-          >,
+          PreparedTrellisEvent<Types.AuthConnectionsOpenedEvent>,
           ValidationError | UnexpectedError
         >;
         listen(
@@ -470,14 +425,12 @@ export interface TrellisAuthClient {
       };
       deviceUserAuthoritiesApproved: {
         publish(
-          event: Omit<Types.AuthDeviceUserAuthoritiesApprovedEvent, "header">,
+          event: Types.AuthDeviceUserAuthoritiesApprovedEvent,
         ): AsyncResult<void, ValidationError | UnexpectedError>;
         prepare(
-          event: Omit<Types.AuthDeviceUserAuthoritiesApprovedEvent, "header">,
+          event: Types.AuthDeviceUserAuthoritiesApprovedEvent,
         ): Result<
-          PreparedTrellisEvent<
-            Omit<Types.AuthDeviceUserAuthoritiesApprovedEvent, "header">
-          >,
+          PreparedTrellisEvent<Types.AuthDeviceUserAuthoritiesApprovedEvent>,
           ValidationError | UnexpectedError
         >;
         listen(
@@ -488,14 +441,12 @@ export interface TrellisAuthClient {
       };
       deviceUserAuthoritiesRequested: {
         publish(
-          event: Omit<Types.AuthDeviceUserAuthoritiesRequestedEvent, "header">,
+          event: Types.AuthDeviceUserAuthoritiesRequestedEvent,
         ): AsyncResult<void, ValidationError | UnexpectedError>;
         prepare(
-          event: Omit<Types.AuthDeviceUserAuthoritiesRequestedEvent, "header">,
+          event: Types.AuthDeviceUserAuthoritiesRequestedEvent,
         ): Result<
-          PreparedTrellisEvent<
-            Omit<Types.AuthDeviceUserAuthoritiesRequestedEvent, "header">
-          >,
+          PreparedTrellisEvent<Types.AuthDeviceUserAuthoritiesRequestedEvent>,
           ValidationError | UnexpectedError
         >;
         listen(
@@ -506,14 +457,12 @@ export interface TrellisAuthClient {
       };
       deviceUserAuthoritiesResolved: {
         publish(
-          event: Omit<Types.AuthDeviceUserAuthoritiesResolvedEvent, "header">,
+          event: Types.AuthDeviceUserAuthoritiesResolvedEvent,
         ): AsyncResult<void, ValidationError | UnexpectedError>;
         prepare(
-          event: Omit<Types.AuthDeviceUserAuthoritiesResolvedEvent, "header">,
+          event: Types.AuthDeviceUserAuthoritiesResolvedEvent,
         ): Result<
-          PreparedTrellisEvent<
-            Omit<Types.AuthDeviceUserAuthoritiesResolvedEvent, "header">
-          >,
+          PreparedTrellisEvent<Types.AuthDeviceUserAuthoritiesResolvedEvent>,
           ValidationError | UnexpectedError
         >;
         listen(
@@ -524,19 +473,13 @@ export interface TrellisAuthClient {
       };
       deviceUserAuthoritiesReviewRequested: {
         publish(
-          event: Omit<
-            Types.AuthDeviceUserAuthoritiesReviewRequestedEvent,
-            "header"
-          >,
+          event: Types.AuthDeviceUserAuthoritiesReviewRequestedEvent,
         ): AsyncResult<void, ValidationError | UnexpectedError>;
         prepare(
-          event: Omit<
-            Types.AuthDeviceUserAuthoritiesReviewRequestedEvent,
-            "header"
-          >,
+          event: Types.AuthDeviceUserAuthoritiesReviewRequestedEvent,
         ): Result<
           PreparedTrellisEvent<
-            Omit<Types.AuthDeviceUserAuthoritiesReviewRequestedEvent, "header">
+            Types.AuthDeviceUserAuthoritiesReviewRequestedEvent
           >,
           ValidationError | UnexpectedError
         >;
@@ -550,12 +493,12 @@ export interface TrellisAuthClient {
       };
       sessionsRevoked: {
         publish(
-          event: Omit<Types.AuthSessionsRevokedEvent, "header">,
+          event: Types.AuthSessionsRevokedEvent,
         ): AsyncResult<void, ValidationError | UnexpectedError>;
         prepare(
-          event: Omit<Types.AuthSessionsRevokedEvent, "header">,
+          event: Types.AuthSessionsRevokedEvent,
         ): Result<
-          PreparedTrellisEvent<Omit<Types.AuthSessionsRevokedEvent, "header">>,
+          PreparedTrellisEvent<Types.AuthSessionsRevokedEvent>,
           ValidationError | UnexpectedError
         >;
         listen(
@@ -565,6 +508,24 @@ export interface TrellisAuthClient {
         ): AsyncResult<void, ValidationError | UnexpectedError>;
       };
     };
+    readonly health: {
+      heartbeat: {
+        publish(
+          event: HealthSdk.HealthHeartbeatEvent,
+        ): AsyncResult<void, ValidationError | UnexpectedError>;
+        prepare(
+          event: HealthSdk.HealthHeartbeatEvent,
+        ): Result<
+          PreparedTrellisEvent<HealthSdk.HealthHeartbeatEvent>,
+          ValidationError | UnexpectedError
+        >;
+        listen(
+          handler: EventCallback<HealthSdk.HealthHeartbeatEvent>,
+          subjectData?: Record<string, unknown>,
+          opts?: EventOpts,
+        ): AsyncResult<void, ValidationError | UnexpectedError>;
+      };
+    };
   };
   readonly feed: {};
   readonly operation: {
@@ -577,167 +538,154 @@ export interface TrellisAuthClient {
 
 export interface Service extends TrellisAuthClient {
   readonly handle: ServiceHandle;
-  with<TDeps>(deps: TDeps): ServiceWithDeps<TDeps>;
 }
 
-export type ServiceWithDeps<TDeps> = Omit<TrellisAuthClient, "event"> & {
-  readonly event: ServiceEventSurface<TDeps>;
-  readonly handle: ServiceHandle<TDeps>;
-  with<TNextDeps>(deps: TNextDeps): ServiceWithDeps<TNextDeps>;
-};
-
-export interface ServiceEventSurface<TDeps> {
+export interface ServiceEventSurface {
   readonly auth: {
     connectionsClosed: {
       publish(
-        event: Omit<Types.AuthConnectionsClosedEvent, "header">,
+        event: Types.AuthConnectionsClosedEvent,
       ): AsyncResult<void, ValidationError | UnexpectedError>;
       prepare(
-        event: Omit<Types.AuthConnectionsClosedEvent, "header">,
+        event: Types.AuthConnectionsClosedEvent,
       ): Result<
-        PreparedTrellisEvent<Omit<Types.AuthConnectionsClosedEvent, "header">>,
+        PreparedTrellisEvent<Types.AuthConnectionsClosedEvent>,
         ValidationError | UnexpectedError
       >;
       listen(
-        handler: ServiceEventHandler<Types.AuthConnectionsClosedEvent, TDeps>,
+        handler: Types.AuthConnectionsClosedEventHandler,
         subjectData?: Record<string, unknown>,
         opts?: EventOpts,
       ): AsyncResult<void, ValidationError | UnexpectedError>;
     };
     connectionsKicked: {
       publish(
-        event: Omit<Types.AuthConnectionsKickedEvent, "header">,
+        event: Types.AuthConnectionsKickedEvent,
       ): AsyncResult<void, ValidationError | UnexpectedError>;
       prepare(
-        event: Omit<Types.AuthConnectionsKickedEvent, "header">,
+        event: Types.AuthConnectionsKickedEvent,
       ): Result<
-        PreparedTrellisEvent<Omit<Types.AuthConnectionsKickedEvent, "header">>,
+        PreparedTrellisEvent<Types.AuthConnectionsKickedEvent>,
         ValidationError | UnexpectedError
       >;
       listen(
-        handler: ServiceEventHandler<Types.AuthConnectionsKickedEvent, TDeps>,
+        handler: Types.AuthConnectionsKickedEventHandler,
         subjectData?: Record<string, unknown>,
         opts?: EventOpts,
       ): AsyncResult<void, ValidationError | UnexpectedError>;
     };
     connectionsOpened: {
       publish(
-        event: Omit<Types.AuthConnectionsOpenedEvent, "header">,
+        event: Types.AuthConnectionsOpenedEvent,
       ): AsyncResult<void, ValidationError | UnexpectedError>;
       prepare(
-        event: Omit<Types.AuthConnectionsOpenedEvent, "header">,
+        event: Types.AuthConnectionsOpenedEvent,
       ): Result<
-        PreparedTrellisEvent<Omit<Types.AuthConnectionsOpenedEvent, "header">>,
+        PreparedTrellisEvent<Types.AuthConnectionsOpenedEvent>,
         ValidationError | UnexpectedError
       >;
       listen(
-        handler: ServiceEventHandler<Types.AuthConnectionsOpenedEvent, TDeps>,
+        handler: Types.AuthConnectionsOpenedEventHandler,
         subjectData?: Record<string, unknown>,
         opts?: EventOpts,
       ): AsyncResult<void, ValidationError | UnexpectedError>;
     };
     deviceUserAuthoritiesApproved: {
       publish(
-        event: Omit<Types.AuthDeviceUserAuthoritiesApprovedEvent, "header">,
+        event: Types.AuthDeviceUserAuthoritiesApprovedEvent,
       ): AsyncResult<void, ValidationError | UnexpectedError>;
       prepare(
-        event: Omit<Types.AuthDeviceUserAuthoritiesApprovedEvent, "header">,
+        event: Types.AuthDeviceUserAuthoritiesApprovedEvent,
       ): Result<
-        PreparedTrellisEvent<
-          Omit<Types.AuthDeviceUserAuthoritiesApprovedEvent, "header">
-        >,
+        PreparedTrellisEvent<Types.AuthDeviceUserAuthoritiesApprovedEvent>,
         ValidationError | UnexpectedError
       >;
       listen(
-        handler: ServiceEventHandler<
-          Types.AuthDeviceUserAuthoritiesApprovedEvent,
-          TDeps
-        >,
+        handler: Types.AuthDeviceUserAuthoritiesApprovedEventHandler,
         subjectData?: Record<string, unknown>,
         opts?: EventOpts,
       ): AsyncResult<void, ValidationError | UnexpectedError>;
     };
     deviceUserAuthoritiesRequested: {
       publish(
-        event: Omit<Types.AuthDeviceUserAuthoritiesRequestedEvent, "header">,
+        event: Types.AuthDeviceUserAuthoritiesRequestedEvent,
       ): AsyncResult<void, ValidationError | UnexpectedError>;
       prepare(
-        event: Omit<Types.AuthDeviceUserAuthoritiesRequestedEvent, "header">,
+        event: Types.AuthDeviceUserAuthoritiesRequestedEvent,
       ): Result<
-        PreparedTrellisEvent<
-          Omit<Types.AuthDeviceUserAuthoritiesRequestedEvent, "header">
-        >,
+        PreparedTrellisEvent<Types.AuthDeviceUserAuthoritiesRequestedEvent>,
         ValidationError | UnexpectedError
       >;
       listen(
-        handler: ServiceEventHandler<
-          Types.AuthDeviceUserAuthoritiesRequestedEvent,
-          TDeps
-        >,
+        handler: Types.AuthDeviceUserAuthoritiesRequestedEventHandler,
         subjectData?: Record<string, unknown>,
         opts?: EventOpts,
       ): AsyncResult<void, ValidationError | UnexpectedError>;
     };
     deviceUserAuthoritiesResolved: {
       publish(
-        event: Omit<Types.AuthDeviceUserAuthoritiesResolvedEvent, "header">,
+        event: Types.AuthDeviceUserAuthoritiesResolvedEvent,
       ): AsyncResult<void, ValidationError | UnexpectedError>;
       prepare(
-        event: Omit<Types.AuthDeviceUserAuthoritiesResolvedEvent, "header">,
+        event: Types.AuthDeviceUserAuthoritiesResolvedEvent,
       ): Result<
-        PreparedTrellisEvent<
-          Omit<Types.AuthDeviceUserAuthoritiesResolvedEvent, "header">
-        >,
+        PreparedTrellisEvent<Types.AuthDeviceUserAuthoritiesResolvedEvent>,
         ValidationError | UnexpectedError
       >;
       listen(
-        handler: ServiceEventHandler<
-          Types.AuthDeviceUserAuthoritiesResolvedEvent,
-          TDeps
-        >,
+        handler: Types.AuthDeviceUserAuthoritiesResolvedEventHandler,
         subjectData?: Record<string, unknown>,
         opts?: EventOpts,
       ): AsyncResult<void, ValidationError | UnexpectedError>;
     };
     deviceUserAuthoritiesReviewRequested: {
       publish(
-        event: Omit<
-          Types.AuthDeviceUserAuthoritiesReviewRequestedEvent,
-          "header"
-        >,
+        event: Types.AuthDeviceUserAuthoritiesReviewRequestedEvent,
       ): AsyncResult<void, ValidationError | UnexpectedError>;
       prepare(
-        event: Omit<
-          Types.AuthDeviceUserAuthoritiesReviewRequestedEvent,
-          "header"
-        >,
+        event: Types.AuthDeviceUserAuthoritiesReviewRequestedEvent,
       ): Result<
         PreparedTrellisEvent<
-          Omit<Types.AuthDeviceUserAuthoritiesReviewRequestedEvent, "header">
+          Types.AuthDeviceUserAuthoritiesReviewRequestedEvent
         >,
         ValidationError | UnexpectedError
       >;
       listen(
-        handler: ServiceEventHandler<
-          Types.AuthDeviceUserAuthoritiesReviewRequestedEvent,
-          TDeps
-        >,
+        handler: Types.AuthDeviceUserAuthoritiesReviewRequestedEventHandler,
         subjectData?: Record<string, unknown>,
         opts?: EventOpts,
       ): AsyncResult<void, ValidationError | UnexpectedError>;
     };
     sessionsRevoked: {
       publish(
-        event: Omit<Types.AuthSessionsRevokedEvent, "header">,
+        event: Types.AuthSessionsRevokedEvent,
       ): AsyncResult<void, ValidationError | UnexpectedError>;
       prepare(
-        event: Omit<Types.AuthSessionsRevokedEvent, "header">,
+        event: Types.AuthSessionsRevokedEvent,
       ): Result<
-        PreparedTrellisEvent<Omit<Types.AuthSessionsRevokedEvent, "header">>,
+        PreparedTrellisEvent<Types.AuthSessionsRevokedEvent>,
         ValidationError | UnexpectedError
       >;
       listen(
-        handler: ServiceEventHandler<Types.AuthSessionsRevokedEvent, TDeps>,
+        handler: Types.AuthSessionsRevokedEventHandler,
+        subjectData?: Record<string, unknown>,
+        opts?: EventOpts,
+      ): AsyncResult<void, ValidationError | UnexpectedError>;
+    };
+  };
+  readonly health: {
+    heartbeat: {
+      publish(
+        event: HealthSdk.HealthHeartbeatEvent,
+      ): AsyncResult<void, ValidationError | UnexpectedError>;
+      prepare(
+        event: HealthSdk.HealthHeartbeatEvent,
+      ): Result<
+        PreparedTrellisEvent<HealthSdk.HealthHeartbeatEvent>,
+        ValidationError | UnexpectedError
+      >;
+      listen(
+        handler: DependencyServiceEventHandler<HealthSdk.HealthHeartbeatEvent>,
         subjectData?: Record<string, unknown>,
         opts?: EventOpts,
       ): AsyncResult<void, ValidationError | UnexpectedError>;
@@ -745,471 +693,165 @@ export interface ServiceEventSurface<TDeps> {
   };
 }
 
-export interface ServiceHandle<TDeps = undefined> {
+export interface ServiceHandle {
   readonly rpc: {
     readonly auth: {
       capabilitiesList(
-        handler: RpcHandler<
-          Types.AuthCapabilitiesListInput,
-          Types.AuthCapabilitiesListOutput,
-          TDeps
-        >,
+        handler: Types.AuthCapabilitiesListHandler,
       ): Promise<void>;
       capabilityGroupsDelete(
-        handler: RpcHandler<
-          Types.AuthCapabilityGroupsDeleteInput,
-          Types.AuthCapabilityGroupsDeleteOutput,
-          TDeps
-        >,
+        handler: Types.AuthCapabilityGroupsDeleteHandler,
       ): Promise<void>;
       capabilityGroupsGet(
-        handler: RpcHandler<
-          Types.AuthCapabilityGroupsGetInput,
-          Types.AuthCapabilityGroupsGetOutput,
-          TDeps
-        >,
+        handler: Types.AuthCapabilityGroupsGetHandler,
       ): Promise<void>;
       capabilityGroupsList(
-        handler: RpcHandler<
-          Types.AuthCapabilityGroupsListInput,
-          Types.AuthCapabilityGroupsListOutput,
-          TDeps
-        >,
+        handler: Types.AuthCapabilityGroupsListHandler,
       ): Promise<void>;
       capabilityGroupsPut(
-        handler: RpcHandler<
-          Types.AuthCapabilityGroupsPutInput,
-          Types.AuthCapabilityGroupsPutOutput,
-          TDeps
-        >,
+        handler: Types.AuthCapabilityGroupsPutHandler,
       ): Promise<void>;
       catalogIssuesResolve(
-        handler: RpcHandler<
-          Types.AuthCatalogIssuesResolveInput,
-          Types.AuthCatalogIssuesResolveOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      connectionsKick(
-        handler: RpcHandler<
-          Types.AuthConnectionsKickInput,
-          Types.AuthConnectionsKickOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      connectionsList(
-        handler: RpcHandler<
-          Types.AuthConnectionsListInput,
-          Types.AuthConnectionsListOutput,
-          TDeps
-        >,
+        handler: Types.AuthCatalogIssuesResolveHandler,
       ): Promise<void>;
+      connectionsKick(handler: Types.AuthConnectionsKickHandler): Promise<void>;
+      connectionsList(handler: Types.AuthConnectionsListHandler): Promise<void>;
       deploymentAuthorityAcceptMigration(
-        handler: RpcHandler<
-          Types.AuthDeploymentAuthorityAcceptMigrationInput,
-          Types.AuthDeploymentAuthorityAcceptMigrationOutput,
-          TDeps
-        >,
+        handler: Types.AuthDeploymentAuthorityAcceptMigrationHandler,
       ): Promise<void>;
       deploymentAuthorityAcceptUpdate(
-        handler: RpcHandler<
-          Types.AuthDeploymentAuthorityAcceptUpdateInput,
-          Types.AuthDeploymentAuthorityAcceptUpdateOutput,
-          TDeps
-        >,
+        handler: Types.AuthDeploymentAuthorityAcceptUpdateHandler,
       ): Promise<void>;
       deploymentAuthorityGet(
-        handler: RpcHandler<
-          Types.AuthDeploymentAuthorityGetInput,
-          Types.AuthDeploymentAuthorityGetOutput,
-          TDeps
-        >,
+        handler: Types.AuthDeploymentAuthorityGetHandler,
       ): Promise<void>;
       deploymentAuthorityGrantOverridesList(
-        handler: RpcHandler<
-          Types.AuthDeploymentAuthorityGrantOverridesListInput,
-          Types.AuthDeploymentAuthorityGrantOverridesListOutput,
-          TDeps
-        >,
+        handler: Types.AuthDeploymentAuthorityGrantOverridesListHandler,
       ): Promise<void>;
       deploymentAuthorityGrantOverridesPut(
-        handler: RpcHandler<
-          Types.AuthDeploymentAuthorityGrantOverridesPutInput,
-          Types.AuthDeploymentAuthorityGrantOverridesPutOutput,
-          TDeps
-        >,
+        handler: Types.AuthDeploymentAuthorityGrantOverridesPutHandler,
       ): Promise<void>;
       deploymentAuthorityGrantOverridesRemove(
-        handler: RpcHandler<
-          Types.AuthDeploymentAuthorityGrantOverridesRemoveInput,
-          Types.AuthDeploymentAuthorityGrantOverridesRemoveOutput,
-          TDeps
-        >,
+        handler: Types.AuthDeploymentAuthorityGrantOverridesRemoveHandler,
       ): Promise<void>;
       deploymentAuthorityList(
-        handler: RpcHandler<
-          Types.AuthDeploymentAuthorityListInput,
-          Types.AuthDeploymentAuthorityListOutput,
-          TDeps
-        >,
+        handler: Types.AuthDeploymentAuthorityListHandler,
       ): Promise<void>;
       deploymentAuthorityPlan(
-        handler: RpcHandler<
-          Types.AuthDeploymentAuthorityPlanInput,
-          Types.AuthDeploymentAuthorityPlanOutput,
-          TDeps
-        >,
+        handler: Types.AuthDeploymentAuthorityPlanHandler,
       ): Promise<void>;
       deploymentAuthorityPlansGet(
-        handler: RpcHandler<
-          Types.AuthDeploymentAuthorityPlansGetInput,
-          Types.AuthDeploymentAuthorityPlansGetOutput,
-          TDeps
-        >,
+        handler: Types.AuthDeploymentAuthorityPlansGetHandler,
       ): Promise<void>;
       deploymentAuthorityPlansList(
-        handler: RpcHandler<
-          Types.AuthDeploymentAuthorityPlansListInput,
-          Types.AuthDeploymentAuthorityPlansListOutput,
-          TDeps
-        >,
+        handler: Types.AuthDeploymentAuthorityPlansListHandler,
       ): Promise<void>;
       deploymentAuthorityReconcile(
-        handler: RpcHandler<
-          Types.AuthDeploymentAuthorityReconcileInput,
-          Types.AuthDeploymentAuthorityReconcileOutput,
-          TDeps
-        >,
+        handler: Types.AuthDeploymentAuthorityReconcileHandler,
       ): Promise<void>;
       deploymentAuthorityReject(
-        handler: RpcHandler<
-          Types.AuthDeploymentAuthorityRejectInput,
-          Types.AuthDeploymentAuthorityRejectOutput,
-          TDeps
-        >,
+        handler: Types.AuthDeploymentAuthorityRejectHandler,
       ): Promise<void>;
       deploymentsCreate(
-        handler: RpcHandler<
-          Types.AuthDeploymentsCreateInput,
-          Types.AuthDeploymentsCreateOutput,
-          TDeps
-        >,
+        handler: Types.AuthDeploymentsCreateHandler,
       ): Promise<void>;
       deploymentsDisable(
-        handler: RpcHandler<
-          Types.AuthDeploymentsDisableInput,
-          Types.AuthDeploymentsDisableOutput,
-          TDeps
-        >,
+        handler: Types.AuthDeploymentsDisableHandler,
       ): Promise<void>;
       deploymentsEnable(
-        handler: RpcHandler<
-          Types.AuthDeploymentsEnableInput,
-          Types.AuthDeploymentsEnableOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      deploymentsList(
-        handler: RpcHandler<
-          Types.AuthDeploymentsListInput,
-          Types.AuthDeploymentsListOutput,
-          TDeps
-        >,
+        handler: Types.AuthDeploymentsEnableHandler,
       ): Promise<void>;
+      deploymentsList(handler: Types.AuthDeploymentsListHandler): Promise<void>;
       deploymentsRemove(
-        handler: RpcHandler<
-          Types.AuthDeploymentsRemoveInput,
-          Types.AuthDeploymentsRemoveOutput,
-          TDeps
-        >,
+        handler: Types.AuthDeploymentsRemoveHandler,
       ): Promise<void>;
       deviceUserAuthoritiesList(
-        handler: RpcHandler<
-          Types.AuthDeviceUserAuthoritiesListInput,
-          Types.AuthDeviceUserAuthoritiesListOutput,
-          TDeps
-        >,
+        handler: Types.AuthDeviceUserAuthoritiesListHandler,
       ): Promise<void>;
       deviceUserAuthoritiesReviewsDecide(
-        handler: RpcHandler<
-          Types.AuthDeviceUserAuthoritiesReviewsDecideInput,
-          Types.AuthDeviceUserAuthoritiesReviewsDecideOutput,
-          TDeps
-        >,
+        handler: Types.AuthDeviceUserAuthoritiesReviewsDecideHandler,
       ): Promise<void>;
       deviceUserAuthoritiesReviewsList(
-        handler: RpcHandler<
-          Types.AuthDeviceUserAuthoritiesReviewsListInput,
-          Types.AuthDeviceUserAuthoritiesReviewsListOutput,
-          TDeps
-        >,
+        handler: Types.AuthDeviceUserAuthoritiesReviewsListHandler,
       ): Promise<void>;
       deviceUserAuthoritiesRevoke(
-        handler: RpcHandler<
-          Types.AuthDeviceUserAuthoritiesRevokeInput,
-          Types.AuthDeviceUserAuthoritiesRevokeOutput,
-          TDeps
-        >,
+        handler: Types.AuthDeviceUserAuthoritiesRevokeHandler,
       ): Promise<void>;
       devicesConnectInfoGet(
-        handler: RpcHandler<
-          Types.AuthDevicesConnectInfoGetInput,
-          Types.AuthDevicesConnectInfoGetOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      devicesDisable(
-        handler: RpcHandler<
-          Types.AuthDevicesDisableInput,
-          Types.AuthDevicesDisableOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      devicesEnable(
-        handler: RpcHandler<
-          Types.AuthDevicesEnableInput,
-          Types.AuthDevicesEnableOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      devicesList(
-        handler: RpcHandler<
-          Types.AuthDevicesListInput,
-          Types.AuthDevicesListOutput,
-          TDeps
-        >,
+        handler: Types.AuthDevicesConnectInfoGetHandler,
       ): Promise<void>;
+      devicesDisable(handler: Types.AuthDevicesDisableHandler): Promise<void>;
+      devicesEnable(handler: Types.AuthDevicesEnableHandler): Promise<void>;
+      devicesList(handler: Types.AuthDevicesListHandler): Promise<void>;
       devicesProvision(
-        handler: RpcHandler<
-          Types.AuthDevicesProvisionInput,
-          Types.AuthDevicesProvisionOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      devicesRemove(
-        handler: RpcHandler<
-          Types.AuthDevicesRemoveInput,
-          Types.AuthDevicesRemoveOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      health(
-        handler: RpcHandler<
-          Types.AuthHealthInput,
-          Types.AuthHealthOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      identitiesList(
-        handler: RpcHandler<
-          Types.AuthIdentitiesListInput,
-          Types.AuthIdentitiesListOutput,
-          TDeps
-        >,
+        handler: Types.AuthDevicesProvisionHandler,
       ): Promise<void>;
+      devicesRemove(handler: Types.AuthDevicesRemoveHandler): Promise<void>;
+      health(handler: Types.AuthHealthHandler): Promise<void>;
+      identitiesList(handler: Types.AuthIdentitiesListHandler): Promise<void>;
       identityGrantsList(
-        handler: RpcHandler<
-          Types.AuthIdentityGrantsListInput,
-          Types.AuthIdentityGrantsListOutput,
-          TDeps
-        >,
+        handler: Types.AuthIdentityGrantsListHandler,
       ): Promise<void>;
       identityGrantsRevoke(
-        handler: RpcHandler<
-          Types.AuthIdentityGrantsRevokeInput,
-          Types.AuthIdentityGrantsRevokeOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      portalsGet(
-        handler: RpcHandler<
-          Types.AuthPortalsGetInput,
-          Types.AuthPortalsGetOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      portalsList(
-        handler: RpcHandler<
-          Types.AuthPortalsListInput,
-          Types.AuthPortalsListOutput,
-          TDeps
-        >,
+        handler: Types.AuthIdentityGrantsRevokeHandler,
       ): Promise<void>;
+      portalsGet(handler: Types.AuthPortalsGetHandler): Promise<void>;
+      portalsList(handler: Types.AuthPortalsListHandler): Promise<void>;
       portalsLoginSettingsGet(
-        handler: RpcHandler<
-          Types.AuthPortalsLoginSettingsGetInput,
-          Types.AuthPortalsLoginSettingsGetOutput,
-          TDeps
-        >,
+        handler: Types.AuthPortalsLoginSettingsGetHandler,
       ): Promise<void>;
       portalsLoginSettingsUpdate(
-        handler: RpcHandler<
-          Types.AuthPortalsLoginSettingsUpdateInput,
-          Types.AuthPortalsLoginSettingsUpdateOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      portalsPut(
-        handler: RpcHandler<
-          Types.AuthPortalsPutInput,
-          Types.AuthPortalsPutOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      portalsRemove(
-        handler: RpcHandler<
-          Types.AuthPortalsRemoveInput,
-          Types.AuthPortalsRemoveOutput,
-          TDeps
-        >,
+        handler: Types.AuthPortalsLoginSettingsUpdateHandler,
       ): Promise<void>;
+      portalsPut(handler: Types.AuthPortalsPutHandler): Promise<void>;
+      portalsRemove(handler: Types.AuthPortalsRemoveHandler): Promise<void>;
       portalsRoutesPut(
-        handler: RpcHandler<
-          Types.AuthPortalsRoutesPutInput,
-          Types.AuthPortalsRoutesPutOutput,
-          TDeps
-        >,
+        handler: Types.AuthPortalsRoutesPutHandler,
       ): Promise<void>;
       portalsRoutesRemove(
-        handler: RpcHandler<
-          Types.AuthPortalsRoutesRemoveInput,
-          Types.AuthPortalsRoutesRemoveOutput,
-          TDeps
-        >,
+        handler: Types.AuthPortalsRoutesRemoveHandler,
       ): Promise<void>;
       requestsValidate(
-        handler: RpcHandler<
-          Types.AuthRequestsValidateInput,
-          Types.AuthRequestsValidateOutput,
-          TDeps
-        >,
+        handler: Types.AuthRequestsValidateHandler,
       ): Promise<void>;
       serviceInstancesDisable(
-        handler: RpcHandler<
-          Types.AuthServiceInstancesDisableInput,
-          Types.AuthServiceInstancesDisableOutput,
-          TDeps
-        >,
+        handler: Types.AuthServiceInstancesDisableHandler,
       ): Promise<void>;
       serviceInstancesEnable(
-        handler: RpcHandler<
-          Types.AuthServiceInstancesEnableInput,
-          Types.AuthServiceInstancesEnableOutput,
-          TDeps
-        >,
+        handler: Types.AuthServiceInstancesEnableHandler,
       ): Promise<void>;
       serviceInstancesList(
-        handler: RpcHandler<
-          Types.AuthServiceInstancesListInput,
-          Types.AuthServiceInstancesListOutput,
-          TDeps
-        >,
+        handler: Types.AuthServiceInstancesListHandler,
       ): Promise<void>;
       serviceInstancesProvision(
-        handler: RpcHandler<
-          Types.AuthServiceInstancesProvisionInput,
-          Types.AuthServiceInstancesProvisionOutput,
-          TDeps
-        >,
+        handler: Types.AuthServiceInstancesProvisionHandler,
       ): Promise<void>;
       serviceInstancesRemove(
-        handler: RpcHandler<
-          Types.AuthServiceInstancesRemoveInput,
-          Types.AuthServiceInstancesRemoveOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      sessionsList(
-        handler: RpcHandler<
-          Types.AuthSessionsListInput,
-          Types.AuthSessionsListOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      sessionsLogout(
-        handler: RpcHandler<
-          Types.AuthSessionsLogoutInput,
-          Types.AuthSessionsLogoutOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      sessionsMe(
-        handler: RpcHandler<
-          Types.AuthSessionsMeInput,
-          Types.AuthSessionsMeOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      sessionsRevoke(
-        handler: RpcHandler<
-          Types.AuthSessionsRevokeInput,
-          Types.AuthSessionsRevokeOutput,
-          TDeps
-        >,
+        handler: Types.AuthServiceInstancesRemoveHandler,
       ): Promise<void>;
+      sessionsList(handler: Types.AuthSessionsListHandler): Promise<void>;
+      sessionsLogout(handler: Types.AuthSessionsLogoutHandler): Promise<void>;
+      sessionsMe(handler: Types.AuthSessionsMeHandler): Promise<void>;
+      sessionsRevoke(handler: Types.AuthSessionsRevokeHandler): Promise<void>;
       userIdentitiesList(
-        handler: RpcHandler<
-          Types.AuthUserIdentitiesListInput,
-          Types.AuthUserIdentitiesListOutput,
-          TDeps
-        >,
+        handler: Types.AuthUserIdentitiesListHandler,
       ): Promise<void>;
       userIdentitiesUnlink(
-        handler: RpcHandler<
-          Types.AuthUserIdentitiesUnlinkInput,
-          Types.AuthUserIdentitiesUnlinkOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      usersCreate(
-        handler: RpcHandler<
-          Types.AuthUsersCreateInput,
-          Types.AuthUsersCreateOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      usersGet(
-        handler: RpcHandler<
-          Types.AuthUsersGetInput,
-          Types.AuthUsersGetOutput,
-          TDeps
-        >,
+        handler: Types.AuthUserIdentitiesUnlinkHandler,
       ): Promise<void>;
+      usersCreate(handler: Types.AuthUsersCreateHandler): Promise<void>;
+      usersGet(handler: Types.AuthUsersGetHandler): Promise<void>;
       usersIdentityLinkCreate(
-        handler: RpcHandler<
-          Types.AuthUsersIdentityLinkCreateInput,
-          Types.AuthUsersIdentityLinkCreateOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      usersList(
-        handler: RpcHandler<
-          Types.AuthUsersListInput,
-          Types.AuthUsersListOutput,
-          TDeps
-        >,
+        handler: Types.AuthUsersIdentityLinkCreateHandler,
       ): Promise<void>;
+      usersList(handler: Types.AuthUsersListHandler): Promise<void>;
       usersPasswordChange(
-        handler: RpcHandler<
-          Types.AuthUsersPasswordChangeInput,
-          Types.AuthUsersPasswordChangeOutput,
-          TDeps
-        >,
+        handler: Types.AuthUsersPasswordChangeHandler,
       ): Promise<void>;
       usersPasswordResetCreate(
-        handler: RpcHandler<
-          Types.AuthUsersPasswordResetCreateInput,
-          Types.AuthUsersPasswordResetCreateOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      usersUpdate(
-        handler: RpcHandler<
-          Types.AuthUsersUpdateInput,
-          Types.AuthUsersUpdateOutput,
-          TDeps
-        >,
+        handler: Types.AuthUsersPasswordResetCreateHandler,
       ): Promise<void>;
+      usersUpdate(handler: Types.AuthUsersUpdateHandler): Promise<void>;
     };
   };
   readonly feed: {};
@@ -1217,13 +859,7 @@ export interface ServiceHandle<TDeps = undefined> {
     readonly auth: {
       deviceUserAuthoritiesResolve:
         & ((
-          handler: OperationHandler<
-            Types.AuthDeviceUserAuthoritiesResolveInput,
-            Types.AuthDeviceUserAuthoritiesResolveProgress,
-            Types.AuthDeviceUserAuthoritiesResolveOutput,
-            {},
-            TDeps
-          >,
+          handler: Types.AuthDeviceUserAuthoritiesResolveOperationHandler,
         ) => Promise<void>)
         & {
           accept(
@@ -1231,7 +867,8 @@ export interface ServiceHandle<TDeps = undefined> {
           ): AsyncResult<
             AcceptedOperation<
               Types.AuthDeviceUserAuthoritiesResolveProgress,
-              Types.AuthDeviceUserAuthoritiesResolveOutput
+              Types.AuthDeviceUserAuthoritiesResolveOutput,
+              Types.AuthDeviceUserAuthoritiesResolveOperationHandlerError
             >,
             UnexpectedError
           >;
@@ -1240,7 +877,8 @@ export interface ServiceHandle<TDeps = undefined> {
           ): AsyncResult<
             OperationRuntimeHandle<
               Types.AuthDeviceUserAuthoritiesResolveProgress,
-              Types.AuthDeviceUserAuthoritiesResolveOutput
+              Types.AuthDeviceUserAuthoritiesResolveOutput,
+              Types.AuthDeviceUserAuthoritiesResolveOperationHandlerError
             >,
             BaseError
           >;