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

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

@@ -1,10 +1,24 @@
 // Generated from ./generated/contracts/manifests/trellis.auth@v1.json
-import type { RpcHandlerFn } from "../../../index.js";
-import type { API } from "./api.js";
+import type {
+  BaseError,
+  EventListenerContext,
+  HandlerTrellis,
+  MaybeAsync,
+  OperationRuntimeHandle,
+  Result,
+  RpcHandlerContext,
+  SessionCaller,
+  TrellisErrorInstance,
+  TrellisEventMessage,
+} from "../../../index.js";
+
+import type { Api } from "./api.js";
+
+export type HandlerClient = HandlerTrellis<Api>;
 
 export const CONTRACT_ID = "trellis.auth@v1" as const;
 export const CONTRACT_DIGEST =
-  "x-9_MjfSThvbn1yc9jAWbaraniKLZ74oUeUqqtZijXQ" as const;
+  "1YrFqkuEcvzJykFCGnDkhNE4ot_Lbt0T1QBDHabTHMo" as const;
 
 export type AuthCapabilitiesListInput = { limit: number; offset?: number };
 export type AuthCapabilitiesListOutput = {
@@ -1768,11 +1782,22 @@ export type AuthServiceInstancesDisableOutput = {
             consumerName: string;
             defaultDeadlineMs?: number;
             dlq: boolean;
+            keyConcurrency?: {
+              heartbeatIntervalMs: number;
+              heartbeatTtlMs: number;
+              key: Array<string>;
+              maxActive: number;
+              stalePolicy: "fail-stale" | "block";
+            };
             logs: boolean;
             maxDeliver: number;
             payload: { schema: string };
             progress: boolean;
             publishPrefix: string;
+            queue?: {
+              maxQueuedPerKey: number;
+              whenFull: "reject" | "coalesce" | "replace-oldest";
+            };
             queueType: string;
             result?: { schema: string };
             workSubject: string;
@@ -1833,11 +1858,22 @@ export type AuthServiceInstancesEnableOutput = {
             consumerName: string;
             defaultDeadlineMs?: number;
             dlq: boolean;
+            keyConcurrency?: {
+              heartbeatIntervalMs: number;
+              heartbeatTtlMs: number;
+              key: Array<string>;
+              maxActive: number;
+              stalePolicy: "fail-stale" | "block";
+            };
             logs: boolean;
             maxDeliver: number;
             payload: { schema: string };
             progress: boolean;
             publishPrefix: string;
+            queue?: {
+              maxQueuedPerKey: number;
+              whenFull: "reject" | "coalesce" | "replace-oldest";
+            };
             queueType: string;
             result?: { schema: string };
             workSubject: string;
@@ -1905,11 +1941,22 @@ export type AuthServiceInstancesListOutput = {
               consumerName: string;
               defaultDeadlineMs?: number;
               dlq: boolean;
+              keyConcurrency?: {
+                heartbeatIntervalMs: number;
+                heartbeatTtlMs: number;
+                key: Array<string>;
+                maxActive: number;
+                stalePolicy: "fail-stale" | "block";
+              };
               logs: boolean;
               maxDeliver: number;
               payload: { schema: string };
               progress: boolean;
               publishPrefix: string;
+              queue?: {
+                maxQueuedPerKey: number;
+                whenFull: "reject" | "coalesce" | "replace-oldest";
+              };
               queueType: string;
               result?: { schema: string };
               workSubject: string;
@@ -1977,11 +2024,22 @@ export type AuthServiceInstancesProvisionOutput = {
             consumerName: string;
             defaultDeadlineMs?: number;
             dlq: boolean;
+            keyConcurrency?: {
+              heartbeatIntervalMs: number;
+              heartbeatTtlMs: number;
+              key: Array<string>;
+              maxActive: number;
+              stalePolicy: "fail-stale" | "block";
+            };
             logs: boolean;
             maxDeliver: number;
             payload: { schema: string };
             progress: boolean;
             publishPrefix: string;
+            queue?: {
+              maxQueuedPerKey: number;
+              whenFull: "reject" | "coalesce" | "replace-oldest";
+            };
             queueType: string;
             result?: { schema: string };
             workSubject: string;
@@ -2283,18 +2341,71 @@ export type AuthDeviceUserAuthoritiesResolveOutput = {
   instanceId: string;
   status: "activated";
 } | { reason?: string; status: "rejected" };
+export type AuthDeviceUserAuthoritiesResolveOperationHandlerError =
+  TrellisErrorInstance;
+export type AuthDeviceUserAuthoritiesResolveOperationHandler = (
+  args: {
+    input: AuthDeviceUserAuthoritiesResolveInput;
+    op: OperationRuntimeHandle<
+      AuthDeviceUserAuthoritiesResolveProgress,
+      AuthDeviceUserAuthoritiesResolveOutput,
+      AuthDeviceUserAuthoritiesResolveOperationHandlerError
+    >;
+    caller: SessionCaller;
+    client: HandlerClient;
+  },
+) => unknown | Promise<unknown>;
 
 export type AuthConnectionsClosedEvent = {
-  header: { id: string; time: string };
-} & { id: string; origin: string; sessionKey: string; userNkey: string };
+  id: string;
+  origin: string;
+  sessionKey: string;
+  userNkey: string;
+};
+export type AuthConnectionsClosedEventMessage = TrellisEventMessage<
+  AuthConnectionsClosedEvent
+>;
+export type AuthConnectionsClosedEventHandler = (
+  args: {
+    event: AuthConnectionsClosedEvent;
+    context: EventListenerContext;
+    client: HandlerClient;
+  },
+) => MaybeAsync<void, BaseError>;
 
 export type AuthConnectionsKickedEvent = {
-  header: { id: string; time: string };
-} & { id: string; kickedBy: string; origin: string; userNkey: string };
+  id: string;
+  kickedBy: string;
+  origin: string;
+  userNkey: string;
+};
+export type AuthConnectionsKickedEventMessage = TrellisEventMessage<
+  AuthConnectionsKickedEvent
+>;
+export type AuthConnectionsKickedEventHandler = (
+  args: {
+    event: AuthConnectionsKickedEvent;
+    context: EventListenerContext;
+    client: HandlerClient;
+  },
+) => MaybeAsync<void, BaseError>;
 
 export type AuthConnectionsOpenedEvent = {
-  header: { id: string; time: string };
-} & { id: string; origin: string; sessionKey: string; userNkey: string };
+  id: string;
+  origin: string;
+  sessionKey: string;
+  userNkey: string;
+};
+export type AuthConnectionsOpenedEventMessage = TrellisEventMessage<
+  AuthConnectionsOpenedEvent
+>;
+export type AuthConnectionsOpenedEventHandler = (
+  args: {
+    event: AuthConnectionsOpenedEvent;
+    context: EventListenerContext;
+    client: HandlerClient;
+  },
+) => MaybeAsync<void, BaseError>;
 
 export type AuthDeviceUserAuthoritiesApprovedEvent = {
   approvedAt: string;
@@ -2315,6 +2426,16 @@ export type AuthDeviceUserAuthoritiesApprovedEvent = {
   };
   reviewId: string;
 };
+export type AuthDeviceUserAuthoritiesApprovedEventMessage = TrellisEventMessage<
+  AuthDeviceUserAuthoritiesApprovedEvent
+>;
+export type AuthDeviceUserAuthoritiesApprovedEventHandler = (
+  args: {
+    event: AuthDeviceUserAuthoritiesApprovedEvent;
+    context: EventListenerContext;
+    client: HandlerClient;
+  },
+) => MaybeAsync<void, BaseError>;
 
 export type AuthDeviceUserAuthoritiesRequestedEvent = {
   deploymentId: string;
@@ -2328,6 +2449,15 @@ export type AuthDeviceUserAuthoritiesRequestedEvent = {
     userId: string;
   };
 };
+export type AuthDeviceUserAuthoritiesRequestedEventMessage =
+  TrellisEventMessage<AuthDeviceUserAuthoritiesRequestedEvent>;
+export type AuthDeviceUserAuthoritiesRequestedEventHandler = (
+  args: {
+    event: AuthDeviceUserAuthoritiesRequestedEvent;
+    context: EventListenerContext;
+    client: HandlerClient;
+  },
+) => MaybeAsync<void, BaseError>;
 
 export type AuthDeviceUserAuthoritiesResolvedEvent = {
   deploymentId: string;
@@ -2342,6 +2472,16 @@ export type AuthDeviceUserAuthoritiesResolvedEvent = {
   };
   reviewId?: string;
 };
+export type AuthDeviceUserAuthoritiesResolvedEventMessage = TrellisEventMessage<
+  AuthDeviceUserAuthoritiesResolvedEvent
+>;
+export type AuthDeviceUserAuthoritiesResolvedEventHandler = (
+  args: {
+    event: AuthDeviceUserAuthoritiesResolvedEvent;
+    context: EventListenerContext;
+    client: HandlerClient;
+  },
+) => MaybeAsync<void, BaseError>;
 
 export type AuthDeviceUserAuthoritiesReviewRequestedEvent = {
   deploymentId: string;
@@ -2356,10 +2496,32 @@ export type AuthDeviceUserAuthoritiesReviewRequestedEvent = {
   };
   reviewId: string;
 };
-
-export type AuthSessionsRevokedEvent =
-  & { header: { id: string; time: string } }
-  & { id: string; origin: string; revokedBy: string; sessionKey: string };
+export type AuthDeviceUserAuthoritiesReviewRequestedEventMessage =
+  TrellisEventMessage<AuthDeviceUserAuthoritiesReviewRequestedEvent>;
+export type AuthDeviceUserAuthoritiesReviewRequestedEventHandler = (
+  args: {
+    event: AuthDeviceUserAuthoritiesReviewRequestedEvent;
+    context: EventListenerContext;
+    client: HandlerClient;
+  },
+) => MaybeAsync<void, BaseError>;
+
+export type AuthSessionsRevokedEvent = {
+  id: string;
+  origin: string;
+  revokedBy: string;
+  sessionKey: string;
+};
+export type AuthSessionsRevokedEventMessage = TrellisEventMessage<
+  AuthSessionsRevokedEvent
+>;
+export type AuthSessionsRevokedEventHandler = (
+  args: {
+    event: AuthSessionsRevokedEvent;
+    context: EventListenerContext;
+    client: HandlerClient;
+  },
+) => MaybeAsync<void, BaseError>;
 
 export interface RpcMap {
   "Auth.Capabilities.List": {
@@ -2619,267 +2781,901 @@ export interface RpcMap {
   };
 }
 
-export type AuthCapabilitiesListHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Capabilities.List"
->;
-export type AuthCapabilityGroupsDeleteHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.CapabilityGroups.Delete"
->;
-export type AuthCapabilityGroupsGetHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.CapabilityGroups.Get"
->;
-export type AuthCapabilityGroupsListHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.CapabilityGroups.List"
->;
-export type AuthCapabilityGroupsPutHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.CapabilityGroups.Put"
->;
-export type AuthCatalogIssuesResolveHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.CatalogIssues.Resolve"
->;
-export type AuthConnectionsKickHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Connections.Kick"
->;
-export type AuthConnectionsListHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Connections.List"
->;
-export type AuthDeploymentAuthorityAcceptMigrationHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.DeploymentAuthority.AcceptMigration"
->;
-export type AuthDeploymentAuthorityAcceptUpdateHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.DeploymentAuthority.AcceptUpdate"
->;
-export type AuthDeploymentAuthorityGetHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.DeploymentAuthority.Get"
->;
-export type AuthDeploymentAuthorityGrantOverridesListHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.DeploymentAuthority.GrantOverrides.List"
->;
-export type AuthDeploymentAuthorityGrantOverridesPutHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.DeploymentAuthority.GrantOverrides.Put"
->;
-export type AuthDeploymentAuthorityGrantOverridesRemoveHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.DeploymentAuthority.GrantOverrides.Remove"
->;
-export type AuthDeploymentAuthorityListHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.DeploymentAuthority.List"
->;
-export type AuthDeploymentAuthorityPlanHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.DeploymentAuthority.Plan"
->;
-export type AuthDeploymentAuthorityPlansGetHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.DeploymentAuthority.Plans.Get"
->;
-export type AuthDeploymentAuthorityPlansListHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.DeploymentAuthority.Plans.List"
->;
-export type AuthDeploymentAuthorityReconcileHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.DeploymentAuthority.Reconcile"
->;
-export type AuthDeploymentAuthorityRejectHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.DeploymentAuthority.Reject"
->;
-export type AuthDeploymentsCreateHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Deployments.Create"
->;
-export type AuthDeploymentsDisableHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Deployments.Disable"
->;
-export type AuthDeploymentsEnableHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Deployments.Enable"
->;
-export type AuthDeploymentsListHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Deployments.List"
->;
-export type AuthDeploymentsRemoveHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Deployments.Remove"
->;
-export type AuthDeviceUserAuthoritiesListHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.DeviceUserAuthorities.List"
->;
-export type AuthDeviceUserAuthoritiesReviewsDecideHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.DeviceUserAuthorities.Reviews.Decide"
->;
-export type AuthDeviceUserAuthoritiesReviewsListHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.DeviceUserAuthorities.Reviews.List"
->;
-export type AuthDeviceUserAuthoritiesRevokeHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.DeviceUserAuthorities.Revoke"
->;
-export type AuthDevicesConnectInfoGetHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Devices.ConnectInfo.Get"
->;
-export type AuthDevicesDisableHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Devices.Disable"
->;
-export type AuthDevicesEnableHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Devices.Enable"
->;
-export type AuthDevicesListHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Devices.List"
->;
-export type AuthDevicesProvisionHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Devices.Provision"
->;
-export type AuthDevicesRemoveHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Devices.Remove"
->;
-export type AuthHealthHandler = RpcHandlerFn<typeof API.owned, "Auth.Health">;
-export type AuthIdentitiesListHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Identities.List"
->;
-export type AuthIdentityGrantsListHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.IdentityGrants.List"
->;
-export type AuthIdentityGrantsRevokeHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.IdentityGrants.Revoke"
->;
-export type AuthPortalsGetHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Portals.Get"
->;
-export type AuthPortalsListHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Portals.List"
->;
-export type AuthPortalsLoginSettingsGetHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Portals.LoginSettings.Get"
->;
-export type AuthPortalsLoginSettingsUpdateHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Portals.LoginSettings.Update"
->;
-export type AuthPortalsPutHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Portals.Put"
->;
-export type AuthPortalsRemoveHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Portals.Remove"
->;
-export type AuthPortalsRoutesPutHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Portals.Routes.Put"
->;
-export type AuthPortalsRoutesRemoveHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Portals.Routes.Remove"
->;
-export type AuthRequestsValidateHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Requests.Validate"
->;
-export type AuthServiceInstancesDisableHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.ServiceInstances.Disable"
->;
-export type AuthServiceInstancesEnableHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.ServiceInstances.Enable"
->;
-export type AuthServiceInstancesListHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.ServiceInstances.List"
->;
-export type AuthServiceInstancesProvisionHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.ServiceInstances.Provision"
->;
-export type AuthServiceInstancesRemoveHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.ServiceInstances.Remove"
->;
-export type AuthSessionsListHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Sessions.List"
->;
-export type AuthSessionsLogoutHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Sessions.Logout"
->;
-export type AuthSessionsMeHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Sessions.Me"
->;
-export type AuthSessionsRevokeHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Sessions.Revoke"
->;
-export type AuthUserIdentitiesListHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.UserIdentities.List"
->;
-export type AuthUserIdentitiesUnlinkHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.UserIdentities.Unlink"
->;
-export type AuthUsersCreateHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Users.Create"
->;
-export type AuthUsersGetHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Users.Get"
->;
-export type AuthUsersIdentityLinkCreateHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Users.IdentityLink.Create"
->;
-export type AuthUsersListHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Users.List"
->;
-export type AuthUsersPasswordChangeHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Users.Password.Change"
->;
-export type AuthUsersPasswordResetCreateHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Users.PasswordReset.Create"
->;
-export type AuthUsersUpdateHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Auth.Users.Update"
+export type AuthCapabilitiesListHandlerError = TrellisErrorInstance;
+export type AuthCapabilitiesListHandlerResult = Result<
+  AuthCapabilitiesListOutput,
+  AuthCapabilitiesListHandlerError
 >;
+export type AuthCapabilitiesListHandler = (
+  args: {
+    input: AuthCapabilitiesListInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthCapabilitiesListHandlerResult
+  | Promise<AuthCapabilitiesListHandlerResult>;
+export type AuthCapabilityGroupsDeleteHandlerError = TrellisErrorInstance;
+export type AuthCapabilityGroupsDeleteHandlerResult = Result<
+  AuthCapabilityGroupsDeleteOutput,
+  AuthCapabilityGroupsDeleteHandlerError
+>;
+export type AuthCapabilityGroupsDeleteHandler = (
+  args: {
+    input: AuthCapabilityGroupsDeleteInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthCapabilityGroupsDeleteHandlerResult
+  | Promise<AuthCapabilityGroupsDeleteHandlerResult>;
+export type AuthCapabilityGroupsGetHandlerError = TrellisErrorInstance;
+export type AuthCapabilityGroupsGetHandlerResult = Result<
+  AuthCapabilityGroupsGetOutput,
+  AuthCapabilityGroupsGetHandlerError
+>;
+export type AuthCapabilityGroupsGetHandler = (
+  args: {
+    input: AuthCapabilityGroupsGetInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthCapabilityGroupsGetHandlerResult
+  | Promise<AuthCapabilityGroupsGetHandlerResult>;
+export type AuthCapabilityGroupsListHandlerError = TrellisErrorInstance;
+export type AuthCapabilityGroupsListHandlerResult = Result<
+  AuthCapabilityGroupsListOutput,
+  AuthCapabilityGroupsListHandlerError
+>;
+export type AuthCapabilityGroupsListHandler = (
+  args: {
+    input: AuthCapabilityGroupsListInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthCapabilityGroupsListHandlerResult
+  | Promise<AuthCapabilityGroupsListHandlerResult>;
+export type AuthCapabilityGroupsPutHandlerError = TrellisErrorInstance;
+export type AuthCapabilityGroupsPutHandlerResult = Result<
+  AuthCapabilityGroupsPutOutput,
+  AuthCapabilityGroupsPutHandlerError
+>;
+export type AuthCapabilityGroupsPutHandler = (
+  args: {
+    input: AuthCapabilityGroupsPutInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthCapabilityGroupsPutHandlerResult
+  | Promise<AuthCapabilityGroupsPutHandlerResult>;
+export type AuthCatalogIssuesResolveHandlerError = TrellisErrorInstance;
+export type AuthCatalogIssuesResolveHandlerResult = Result<
+  AuthCatalogIssuesResolveOutput,
+  AuthCatalogIssuesResolveHandlerError
+>;
+export type AuthCatalogIssuesResolveHandler = (
+  args: {
+    input: AuthCatalogIssuesResolveInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthCatalogIssuesResolveHandlerResult
+  | Promise<AuthCatalogIssuesResolveHandlerResult>;
+export type AuthConnectionsKickHandlerError = TrellisErrorInstance;
+export type AuthConnectionsKickHandlerResult = Result<
+  AuthConnectionsKickOutput,
+  AuthConnectionsKickHandlerError
+>;
+export type AuthConnectionsKickHandler = (
+  args: {
+    input: AuthConnectionsKickInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthConnectionsKickHandlerResult
+  | Promise<AuthConnectionsKickHandlerResult>;
+export type AuthConnectionsListHandlerError = TrellisErrorInstance;
+export type AuthConnectionsListHandlerResult = Result<
+  AuthConnectionsListOutput,
+  AuthConnectionsListHandlerError
+>;
+export type AuthConnectionsListHandler = (
+  args: {
+    input: AuthConnectionsListInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthConnectionsListHandlerResult
+  | Promise<AuthConnectionsListHandlerResult>;
+export type AuthDeploymentAuthorityAcceptMigrationHandlerError =
+  TrellisErrorInstance;
+export type AuthDeploymentAuthorityAcceptMigrationHandlerResult = Result<
+  AuthDeploymentAuthorityAcceptMigrationOutput,
+  AuthDeploymentAuthorityAcceptMigrationHandlerError
+>;
+export type AuthDeploymentAuthorityAcceptMigrationHandler = (
+  args: {
+    input: AuthDeploymentAuthorityAcceptMigrationInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDeploymentAuthorityAcceptMigrationHandlerResult
+  | Promise<AuthDeploymentAuthorityAcceptMigrationHandlerResult>;
+export type AuthDeploymentAuthorityAcceptUpdateHandlerError =
+  TrellisErrorInstance;
+export type AuthDeploymentAuthorityAcceptUpdateHandlerResult = Result<
+  AuthDeploymentAuthorityAcceptUpdateOutput,
+  AuthDeploymentAuthorityAcceptUpdateHandlerError
+>;
+export type AuthDeploymentAuthorityAcceptUpdateHandler = (
+  args: {
+    input: AuthDeploymentAuthorityAcceptUpdateInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDeploymentAuthorityAcceptUpdateHandlerResult
+  | Promise<AuthDeploymentAuthorityAcceptUpdateHandlerResult>;
+export type AuthDeploymentAuthorityGetHandlerError = TrellisErrorInstance;
+export type AuthDeploymentAuthorityGetHandlerResult = Result<
+  AuthDeploymentAuthorityGetOutput,
+  AuthDeploymentAuthorityGetHandlerError
+>;
+export type AuthDeploymentAuthorityGetHandler = (
+  args: {
+    input: AuthDeploymentAuthorityGetInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDeploymentAuthorityGetHandlerResult
+  | Promise<AuthDeploymentAuthorityGetHandlerResult>;
+export type AuthDeploymentAuthorityGrantOverridesListHandlerError =
+  TrellisErrorInstance;
+export type AuthDeploymentAuthorityGrantOverridesListHandlerResult = Result<
+  AuthDeploymentAuthorityGrantOverridesListOutput,
+  AuthDeploymentAuthorityGrantOverridesListHandlerError
+>;
+export type AuthDeploymentAuthorityGrantOverridesListHandler = (
+  args: {
+    input: AuthDeploymentAuthorityGrantOverridesListInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDeploymentAuthorityGrantOverridesListHandlerResult
+  | Promise<AuthDeploymentAuthorityGrantOverridesListHandlerResult>;
+export type AuthDeploymentAuthorityGrantOverridesPutHandlerError =
+  TrellisErrorInstance;
+export type AuthDeploymentAuthorityGrantOverridesPutHandlerResult = Result<
+  AuthDeploymentAuthorityGrantOverridesPutOutput,
+  AuthDeploymentAuthorityGrantOverridesPutHandlerError
+>;
+export type AuthDeploymentAuthorityGrantOverridesPutHandler = (
+  args: {
+    input: AuthDeploymentAuthorityGrantOverridesPutInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDeploymentAuthorityGrantOverridesPutHandlerResult
+  | Promise<AuthDeploymentAuthorityGrantOverridesPutHandlerResult>;
+export type AuthDeploymentAuthorityGrantOverridesRemoveHandlerError =
+  TrellisErrorInstance;
+export type AuthDeploymentAuthorityGrantOverridesRemoveHandlerResult = Result<
+  AuthDeploymentAuthorityGrantOverridesRemoveOutput,
+  AuthDeploymentAuthorityGrantOverridesRemoveHandlerError
+>;
+export type AuthDeploymentAuthorityGrantOverridesRemoveHandler = (
+  args: {
+    input: AuthDeploymentAuthorityGrantOverridesRemoveInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDeploymentAuthorityGrantOverridesRemoveHandlerResult
+  | Promise<AuthDeploymentAuthorityGrantOverridesRemoveHandlerResult>;
+export type AuthDeploymentAuthorityListHandlerError = TrellisErrorInstance;
+export type AuthDeploymentAuthorityListHandlerResult = Result<
+  AuthDeploymentAuthorityListOutput,
+  AuthDeploymentAuthorityListHandlerError
+>;
+export type AuthDeploymentAuthorityListHandler = (
+  args: {
+    input: AuthDeploymentAuthorityListInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDeploymentAuthorityListHandlerResult
+  | Promise<AuthDeploymentAuthorityListHandlerResult>;
+export type AuthDeploymentAuthorityPlanHandlerError = TrellisErrorInstance;
+export type AuthDeploymentAuthorityPlanHandlerResult = Result<
+  AuthDeploymentAuthorityPlanOutput,
+  AuthDeploymentAuthorityPlanHandlerError
+>;
+export type AuthDeploymentAuthorityPlanHandler = (
+  args: {
+    input: AuthDeploymentAuthorityPlanInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDeploymentAuthorityPlanHandlerResult
+  | Promise<AuthDeploymentAuthorityPlanHandlerResult>;
+export type AuthDeploymentAuthorityPlansGetHandlerError = TrellisErrorInstance;
+export type AuthDeploymentAuthorityPlansGetHandlerResult = Result<
+  AuthDeploymentAuthorityPlansGetOutput,
+  AuthDeploymentAuthorityPlansGetHandlerError
+>;
+export type AuthDeploymentAuthorityPlansGetHandler = (
+  args: {
+    input: AuthDeploymentAuthorityPlansGetInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDeploymentAuthorityPlansGetHandlerResult
+  | Promise<AuthDeploymentAuthorityPlansGetHandlerResult>;
+export type AuthDeploymentAuthorityPlansListHandlerError = TrellisErrorInstance;
+export type AuthDeploymentAuthorityPlansListHandlerResult = Result<
+  AuthDeploymentAuthorityPlansListOutput,
+  AuthDeploymentAuthorityPlansListHandlerError
+>;
+export type AuthDeploymentAuthorityPlansListHandler = (
+  args: {
+    input: AuthDeploymentAuthorityPlansListInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDeploymentAuthorityPlansListHandlerResult
+  | Promise<AuthDeploymentAuthorityPlansListHandlerResult>;
+export type AuthDeploymentAuthorityReconcileHandlerError = TrellisErrorInstance;
+export type AuthDeploymentAuthorityReconcileHandlerResult = Result<
+  AuthDeploymentAuthorityReconcileOutput,
+  AuthDeploymentAuthorityReconcileHandlerError
+>;
+export type AuthDeploymentAuthorityReconcileHandler = (
+  args: {
+    input: AuthDeploymentAuthorityReconcileInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDeploymentAuthorityReconcileHandlerResult
+  | Promise<AuthDeploymentAuthorityReconcileHandlerResult>;
+export type AuthDeploymentAuthorityRejectHandlerError = TrellisErrorInstance;
+export type AuthDeploymentAuthorityRejectHandlerResult = Result<
+  AuthDeploymentAuthorityRejectOutput,
+  AuthDeploymentAuthorityRejectHandlerError
+>;
+export type AuthDeploymentAuthorityRejectHandler = (
+  args: {
+    input: AuthDeploymentAuthorityRejectInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDeploymentAuthorityRejectHandlerResult
+  | Promise<AuthDeploymentAuthorityRejectHandlerResult>;
+export type AuthDeploymentsCreateHandlerError = TrellisErrorInstance;
+export type AuthDeploymentsCreateHandlerResult = Result<
+  AuthDeploymentsCreateOutput,
+  AuthDeploymentsCreateHandlerError
+>;
+export type AuthDeploymentsCreateHandler = (
+  args: {
+    input: AuthDeploymentsCreateInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDeploymentsCreateHandlerResult
+  | Promise<AuthDeploymentsCreateHandlerResult>;
+export type AuthDeploymentsDisableHandlerError = TrellisErrorInstance;
+export type AuthDeploymentsDisableHandlerResult = Result<
+  AuthDeploymentsDisableOutput,
+  AuthDeploymentsDisableHandlerError
+>;
+export type AuthDeploymentsDisableHandler = (
+  args: {
+    input: AuthDeploymentsDisableInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDeploymentsDisableHandlerResult
+  | Promise<AuthDeploymentsDisableHandlerResult>;
+export type AuthDeploymentsEnableHandlerError = TrellisErrorInstance;
+export type AuthDeploymentsEnableHandlerResult = Result<
+  AuthDeploymentsEnableOutput,
+  AuthDeploymentsEnableHandlerError
+>;
+export type AuthDeploymentsEnableHandler = (
+  args: {
+    input: AuthDeploymentsEnableInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDeploymentsEnableHandlerResult
+  | Promise<AuthDeploymentsEnableHandlerResult>;
+export type AuthDeploymentsListHandlerError = TrellisErrorInstance;
+export type AuthDeploymentsListHandlerResult = Result<
+  AuthDeploymentsListOutput,
+  AuthDeploymentsListHandlerError
+>;
+export type AuthDeploymentsListHandler = (
+  args: {
+    input: AuthDeploymentsListInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDeploymentsListHandlerResult
+  | Promise<AuthDeploymentsListHandlerResult>;
+export type AuthDeploymentsRemoveHandlerError = TrellisErrorInstance;
+export type AuthDeploymentsRemoveHandlerResult = Result<
+  AuthDeploymentsRemoveOutput,
+  AuthDeploymentsRemoveHandlerError
+>;
+export type AuthDeploymentsRemoveHandler = (
+  args: {
+    input: AuthDeploymentsRemoveInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDeploymentsRemoveHandlerResult
+  | Promise<AuthDeploymentsRemoveHandlerResult>;
+export type AuthDeviceUserAuthoritiesListHandlerError = TrellisErrorInstance;
+export type AuthDeviceUserAuthoritiesListHandlerResult = Result<
+  AuthDeviceUserAuthoritiesListOutput,
+  AuthDeviceUserAuthoritiesListHandlerError
+>;
+export type AuthDeviceUserAuthoritiesListHandler = (
+  args: {
+    input: AuthDeviceUserAuthoritiesListInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDeviceUserAuthoritiesListHandlerResult
+  | Promise<AuthDeviceUserAuthoritiesListHandlerResult>;
+export type AuthDeviceUserAuthoritiesReviewsDecideHandlerError =
+  TrellisErrorInstance;
+export type AuthDeviceUserAuthoritiesReviewsDecideHandlerResult = Result<
+  AuthDeviceUserAuthoritiesReviewsDecideOutput,
+  AuthDeviceUserAuthoritiesReviewsDecideHandlerError
+>;
+export type AuthDeviceUserAuthoritiesReviewsDecideHandler = (
+  args: {
+    input: AuthDeviceUserAuthoritiesReviewsDecideInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDeviceUserAuthoritiesReviewsDecideHandlerResult
+  | Promise<AuthDeviceUserAuthoritiesReviewsDecideHandlerResult>;
+export type AuthDeviceUserAuthoritiesReviewsListHandlerError =
+  TrellisErrorInstance;
+export type AuthDeviceUserAuthoritiesReviewsListHandlerResult = Result<
+  AuthDeviceUserAuthoritiesReviewsListOutput,
+  AuthDeviceUserAuthoritiesReviewsListHandlerError
+>;
+export type AuthDeviceUserAuthoritiesReviewsListHandler = (
+  args: {
+    input: AuthDeviceUserAuthoritiesReviewsListInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDeviceUserAuthoritiesReviewsListHandlerResult
+  | Promise<AuthDeviceUserAuthoritiesReviewsListHandlerResult>;
+export type AuthDeviceUserAuthoritiesRevokeHandlerError = TrellisErrorInstance;
+export type AuthDeviceUserAuthoritiesRevokeHandlerResult = Result<
+  AuthDeviceUserAuthoritiesRevokeOutput,
+  AuthDeviceUserAuthoritiesRevokeHandlerError
+>;
+export type AuthDeviceUserAuthoritiesRevokeHandler = (
+  args: {
+    input: AuthDeviceUserAuthoritiesRevokeInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDeviceUserAuthoritiesRevokeHandlerResult
+  | Promise<AuthDeviceUserAuthoritiesRevokeHandlerResult>;
+export type AuthDevicesConnectInfoGetHandlerError = TrellisErrorInstance;
+export type AuthDevicesConnectInfoGetHandlerResult = Result<
+  AuthDevicesConnectInfoGetOutput,
+  AuthDevicesConnectInfoGetHandlerError
+>;
+export type AuthDevicesConnectInfoGetHandler = (
+  args: {
+    input: AuthDevicesConnectInfoGetInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDevicesConnectInfoGetHandlerResult
+  | Promise<AuthDevicesConnectInfoGetHandlerResult>;
+export type AuthDevicesDisableHandlerError = TrellisErrorInstance;
+export type AuthDevicesDisableHandlerResult = Result<
+  AuthDevicesDisableOutput,
+  AuthDevicesDisableHandlerError
+>;
+export type AuthDevicesDisableHandler = (
+  args: {
+    input: AuthDevicesDisableInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => AuthDevicesDisableHandlerResult | Promise<AuthDevicesDisableHandlerResult>;
+export type AuthDevicesEnableHandlerError = TrellisErrorInstance;
+export type AuthDevicesEnableHandlerResult = Result<
+  AuthDevicesEnableOutput,
+  AuthDevicesEnableHandlerError
+>;
+export type AuthDevicesEnableHandler = (
+  args: {
+    input: AuthDevicesEnableInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => AuthDevicesEnableHandlerResult | Promise<AuthDevicesEnableHandlerResult>;
+export type AuthDevicesListHandlerError = TrellisErrorInstance;
+export type AuthDevicesListHandlerResult = Result<
+  AuthDevicesListOutput,
+  AuthDevicesListHandlerError
+>;
+export type AuthDevicesListHandler = (
+  args: {
+    input: AuthDevicesListInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => AuthDevicesListHandlerResult | Promise<AuthDevicesListHandlerResult>;
+export type AuthDevicesProvisionHandlerError = TrellisErrorInstance;
+export type AuthDevicesProvisionHandlerResult = Result<
+  AuthDevicesProvisionOutput,
+  AuthDevicesProvisionHandlerError
+>;
+export type AuthDevicesProvisionHandler = (
+  args: {
+    input: AuthDevicesProvisionInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthDevicesProvisionHandlerResult
+  | Promise<AuthDevicesProvisionHandlerResult>;
+export type AuthDevicesRemoveHandlerError = TrellisErrorInstance;
+export type AuthDevicesRemoveHandlerResult = Result<
+  AuthDevicesRemoveOutput,
+  AuthDevicesRemoveHandlerError
+>;
+export type AuthDevicesRemoveHandler = (
+  args: {
+    input: AuthDevicesRemoveInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => AuthDevicesRemoveHandlerResult | Promise<AuthDevicesRemoveHandlerResult>;
+export type AuthHealthHandlerError = TrellisErrorInstance;
+export type AuthHealthHandlerResult = Result<
+  AuthHealthOutput,
+  AuthHealthHandlerError
+>;
+export type AuthHealthHandler = (
+  args: {
+    input: AuthHealthInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => AuthHealthHandlerResult | Promise<AuthHealthHandlerResult>;
+export type AuthIdentitiesListHandlerError = TrellisErrorInstance;
+export type AuthIdentitiesListHandlerResult = Result<
+  AuthIdentitiesListOutput,
+  AuthIdentitiesListHandlerError
+>;
+export type AuthIdentitiesListHandler = (
+  args: {
+    input: AuthIdentitiesListInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => AuthIdentitiesListHandlerResult | Promise<AuthIdentitiesListHandlerResult>;
+export type AuthIdentityGrantsListHandlerError = TrellisErrorInstance;
+export type AuthIdentityGrantsListHandlerResult = Result<
+  AuthIdentityGrantsListOutput,
+  AuthIdentityGrantsListHandlerError
+>;
+export type AuthIdentityGrantsListHandler = (
+  args: {
+    input: AuthIdentityGrantsListInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthIdentityGrantsListHandlerResult
+  | Promise<AuthIdentityGrantsListHandlerResult>;
+export type AuthIdentityGrantsRevokeHandlerError = TrellisErrorInstance;
+export type AuthIdentityGrantsRevokeHandlerResult = Result<
+  AuthIdentityGrantsRevokeOutput,
+  AuthIdentityGrantsRevokeHandlerError
+>;
+export type AuthIdentityGrantsRevokeHandler = (
+  args: {
+    input: AuthIdentityGrantsRevokeInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthIdentityGrantsRevokeHandlerResult
+  | Promise<AuthIdentityGrantsRevokeHandlerResult>;
+export type AuthPortalsGetHandlerError = TrellisErrorInstance;
+export type AuthPortalsGetHandlerResult = Result<
+  AuthPortalsGetOutput,
+  AuthPortalsGetHandlerError
+>;
+export type AuthPortalsGetHandler = (
+  args: {
+    input: AuthPortalsGetInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => AuthPortalsGetHandlerResult | Promise<AuthPortalsGetHandlerResult>;
+export type AuthPortalsListHandlerError = TrellisErrorInstance;
+export type AuthPortalsListHandlerResult = Result<
+  AuthPortalsListOutput,
+  AuthPortalsListHandlerError
+>;
+export type AuthPortalsListHandler = (
+  args: {
+    input: AuthPortalsListInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => AuthPortalsListHandlerResult | Promise<AuthPortalsListHandlerResult>;
+export type AuthPortalsLoginSettingsGetHandlerError = TrellisErrorInstance;
+export type AuthPortalsLoginSettingsGetHandlerResult = Result<
+  AuthPortalsLoginSettingsGetOutput,
+  AuthPortalsLoginSettingsGetHandlerError
+>;
+export type AuthPortalsLoginSettingsGetHandler = (
+  args: {
+    input: AuthPortalsLoginSettingsGetInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthPortalsLoginSettingsGetHandlerResult
+  | Promise<AuthPortalsLoginSettingsGetHandlerResult>;
+export type AuthPortalsLoginSettingsUpdateHandlerError = TrellisErrorInstance;
+export type AuthPortalsLoginSettingsUpdateHandlerResult = Result<
+  AuthPortalsLoginSettingsUpdateOutput,
+  AuthPortalsLoginSettingsUpdateHandlerError
+>;
+export type AuthPortalsLoginSettingsUpdateHandler = (
+  args: {
+    input: AuthPortalsLoginSettingsUpdateInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthPortalsLoginSettingsUpdateHandlerResult
+  | Promise<AuthPortalsLoginSettingsUpdateHandlerResult>;
+export type AuthPortalsPutHandlerError = TrellisErrorInstance;
+export type AuthPortalsPutHandlerResult = Result<
+  AuthPortalsPutOutput,
+  AuthPortalsPutHandlerError
+>;
+export type AuthPortalsPutHandler = (
+  args: {
+    input: AuthPortalsPutInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => AuthPortalsPutHandlerResult | Promise<AuthPortalsPutHandlerResult>;
+export type AuthPortalsRemoveHandlerError = TrellisErrorInstance;
+export type AuthPortalsRemoveHandlerResult = Result<
+  AuthPortalsRemoveOutput,
+  AuthPortalsRemoveHandlerError
+>;
+export type AuthPortalsRemoveHandler = (
+  args: {
+    input: AuthPortalsRemoveInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => AuthPortalsRemoveHandlerResult | Promise<AuthPortalsRemoveHandlerResult>;
+export type AuthPortalsRoutesPutHandlerError = TrellisErrorInstance;
+export type AuthPortalsRoutesPutHandlerResult = Result<
+  AuthPortalsRoutesPutOutput,
+  AuthPortalsRoutesPutHandlerError
+>;
+export type AuthPortalsRoutesPutHandler = (
+  args: {
+    input: AuthPortalsRoutesPutInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthPortalsRoutesPutHandlerResult
+  | Promise<AuthPortalsRoutesPutHandlerResult>;
+export type AuthPortalsRoutesRemoveHandlerError = TrellisErrorInstance;
+export type AuthPortalsRoutesRemoveHandlerResult = Result<
+  AuthPortalsRoutesRemoveOutput,
+  AuthPortalsRoutesRemoveHandlerError
+>;
+export type AuthPortalsRoutesRemoveHandler = (
+  args: {
+    input: AuthPortalsRoutesRemoveInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthPortalsRoutesRemoveHandlerResult
+  | Promise<AuthPortalsRoutesRemoveHandlerResult>;
+export type AuthRequestsValidateHandlerError = TrellisErrorInstance;
+export type AuthRequestsValidateHandlerResult = Result<
+  AuthRequestsValidateOutput,
+  AuthRequestsValidateHandlerError
+>;
+export type AuthRequestsValidateHandler = (
+  args: {
+    input: AuthRequestsValidateInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthRequestsValidateHandlerResult
+  | Promise<AuthRequestsValidateHandlerResult>;
+export type AuthServiceInstancesDisableHandlerError = TrellisErrorInstance;
+export type AuthServiceInstancesDisableHandlerResult = Result<
+  AuthServiceInstancesDisableOutput,
+  AuthServiceInstancesDisableHandlerError
+>;
+export type AuthServiceInstancesDisableHandler = (
+  args: {
+    input: AuthServiceInstancesDisableInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthServiceInstancesDisableHandlerResult
+  | Promise<AuthServiceInstancesDisableHandlerResult>;
+export type AuthServiceInstancesEnableHandlerError = TrellisErrorInstance;
+export type AuthServiceInstancesEnableHandlerResult = Result<
+  AuthServiceInstancesEnableOutput,
+  AuthServiceInstancesEnableHandlerError
+>;
+export type AuthServiceInstancesEnableHandler = (
+  args: {
+    input: AuthServiceInstancesEnableInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthServiceInstancesEnableHandlerResult
+  | Promise<AuthServiceInstancesEnableHandlerResult>;
+export type AuthServiceInstancesListHandlerError = TrellisErrorInstance;
+export type AuthServiceInstancesListHandlerResult = Result<
+  AuthServiceInstancesListOutput,
+  AuthServiceInstancesListHandlerError
+>;
+export type AuthServiceInstancesListHandler = (
+  args: {
+    input: AuthServiceInstancesListInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthServiceInstancesListHandlerResult
+  | Promise<AuthServiceInstancesListHandlerResult>;
+export type AuthServiceInstancesProvisionHandlerError = TrellisErrorInstance;
+export type AuthServiceInstancesProvisionHandlerResult = Result<
+  AuthServiceInstancesProvisionOutput,
+  AuthServiceInstancesProvisionHandlerError
+>;
+export type AuthServiceInstancesProvisionHandler = (
+  args: {
+    input: AuthServiceInstancesProvisionInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthServiceInstancesProvisionHandlerResult
+  | Promise<AuthServiceInstancesProvisionHandlerResult>;
+export type AuthServiceInstancesRemoveHandlerError = TrellisErrorInstance;
+export type AuthServiceInstancesRemoveHandlerResult = Result<
+  AuthServiceInstancesRemoveOutput,
+  AuthServiceInstancesRemoveHandlerError
+>;
+export type AuthServiceInstancesRemoveHandler = (
+  args: {
+    input: AuthServiceInstancesRemoveInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthServiceInstancesRemoveHandlerResult
+  | Promise<AuthServiceInstancesRemoveHandlerResult>;
+export type AuthSessionsListHandlerError = TrellisErrorInstance;
+export type AuthSessionsListHandlerResult = Result<
+  AuthSessionsListOutput,
+  AuthSessionsListHandlerError
+>;
+export type AuthSessionsListHandler = (
+  args: {
+    input: AuthSessionsListInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => AuthSessionsListHandlerResult | Promise<AuthSessionsListHandlerResult>;
+export type AuthSessionsLogoutHandlerError = TrellisErrorInstance;
+export type AuthSessionsLogoutHandlerResult = Result<
+  AuthSessionsLogoutOutput,
+  AuthSessionsLogoutHandlerError
+>;
+export type AuthSessionsLogoutHandler = (
+  args: {
+    input: AuthSessionsLogoutInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => AuthSessionsLogoutHandlerResult | Promise<AuthSessionsLogoutHandlerResult>;
+export type AuthSessionsMeHandlerError = TrellisErrorInstance;
+export type AuthSessionsMeHandlerResult = Result<
+  AuthSessionsMeOutput,
+  AuthSessionsMeHandlerError
+>;
+export type AuthSessionsMeHandler = (
+  args: {
+    input: AuthSessionsMeInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => AuthSessionsMeHandlerResult | Promise<AuthSessionsMeHandlerResult>;
+export type AuthSessionsRevokeHandlerError = TrellisErrorInstance;
+export type AuthSessionsRevokeHandlerResult = Result<
+  AuthSessionsRevokeOutput,
+  AuthSessionsRevokeHandlerError
+>;
+export type AuthSessionsRevokeHandler = (
+  args: {
+    input: AuthSessionsRevokeInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => AuthSessionsRevokeHandlerResult | Promise<AuthSessionsRevokeHandlerResult>;
+export type AuthUserIdentitiesListHandlerError = TrellisErrorInstance;
+export type AuthUserIdentitiesListHandlerResult = Result<
+  AuthUserIdentitiesListOutput,
+  AuthUserIdentitiesListHandlerError
+>;
+export type AuthUserIdentitiesListHandler = (
+  args: {
+    input: AuthUserIdentitiesListInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthUserIdentitiesListHandlerResult
+  | Promise<AuthUserIdentitiesListHandlerResult>;
+export type AuthUserIdentitiesUnlinkHandlerError = TrellisErrorInstance;
+export type AuthUserIdentitiesUnlinkHandlerResult = Result<
+  AuthUserIdentitiesUnlinkOutput,
+  AuthUserIdentitiesUnlinkHandlerError
+>;
+export type AuthUserIdentitiesUnlinkHandler = (
+  args: {
+    input: AuthUserIdentitiesUnlinkInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthUserIdentitiesUnlinkHandlerResult
+  | Promise<AuthUserIdentitiesUnlinkHandlerResult>;
+export type AuthUsersCreateHandlerError = TrellisErrorInstance;
+export type AuthUsersCreateHandlerResult = Result<
+  AuthUsersCreateOutput,
+  AuthUsersCreateHandlerError
+>;
+export type AuthUsersCreateHandler = (
+  args: {
+    input: AuthUsersCreateInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => AuthUsersCreateHandlerResult | Promise<AuthUsersCreateHandlerResult>;
+export type AuthUsersGetHandlerError = TrellisErrorInstance;
+export type AuthUsersGetHandlerResult = Result<
+  AuthUsersGetOutput,
+  AuthUsersGetHandlerError
+>;
+export type AuthUsersGetHandler = (
+  args: {
+    input: AuthUsersGetInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => AuthUsersGetHandlerResult | Promise<AuthUsersGetHandlerResult>;
+export type AuthUsersIdentityLinkCreateHandlerError = TrellisErrorInstance;
+export type AuthUsersIdentityLinkCreateHandlerResult = Result<
+  AuthUsersIdentityLinkCreateOutput,
+  AuthUsersIdentityLinkCreateHandlerError
+>;
+export type AuthUsersIdentityLinkCreateHandler = (
+  args: {
+    input: AuthUsersIdentityLinkCreateInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthUsersIdentityLinkCreateHandlerResult
+  | Promise<AuthUsersIdentityLinkCreateHandlerResult>;
+export type AuthUsersListHandlerError = TrellisErrorInstance;
+export type AuthUsersListHandlerResult = Result<
+  AuthUsersListOutput,
+  AuthUsersListHandlerError
+>;
+export type AuthUsersListHandler = (
+  args: {
+    input: AuthUsersListInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => AuthUsersListHandlerResult | Promise<AuthUsersListHandlerResult>;
+export type AuthUsersPasswordChangeHandlerError = TrellisErrorInstance;
+export type AuthUsersPasswordChangeHandlerResult = Result<
+  AuthUsersPasswordChangeOutput,
+  AuthUsersPasswordChangeHandlerError
+>;
+export type AuthUsersPasswordChangeHandler = (
+  args: {
+    input: AuthUsersPasswordChangeInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthUsersPasswordChangeHandlerResult
+  | Promise<AuthUsersPasswordChangeHandlerResult>;
+export type AuthUsersPasswordResetCreateHandlerError = TrellisErrorInstance;
+export type AuthUsersPasswordResetCreateHandlerResult = Result<
+  AuthUsersPasswordResetCreateOutput,
+  AuthUsersPasswordResetCreateHandlerError
+>;
+export type AuthUsersPasswordResetCreateHandler = (
+  args: {
+    input: AuthUsersPasswordResetCreateInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | AuthUsersPasswordResetCreateHandlerResult
+  | Promise<AuthUsersPasswordResetCreateHandlerResult>;
+export type AuthUsersUpdateHandlerError = TrellisErrorInstance;
+export type AuthUsersUpdateHandlerResult = Result<
+  AuthUsersUpdateOutput,
+  AuthUsersUpdateHandlerError
+>;
+export type AuthUsersUpdateHandler = (
+  args: {
+    input: AuthUsersUpdateInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => AuthUsersUpdateHandlerResult | Promise<AuthUsersUpdateHandlerResult>;
 
 export interface EventMap {
   "Auth.Connections.Closed": { event: AuthConnectionsClosedEvent };