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

package/script/generated-sdk/auth/types.d.ts

@@ -1,7 +1,8 @@
-import type { RpcHandlerFn } from "@qlever-llc/trellis";
-import type { API } from "./api.js";
+import type { BaseError, EventListenerContext, HandlerTrellis, MaybeAsync, OperationRuntimeHandle, Result, RpcHandlerContext, SessionCaller, TrellisErrorInstance, TrellisEventMessage } from "@qlever-llc/trellis";
+import type { Api } from "./api.js";
+export type HandlerClient = HandlerTrellis<Api>;
 export declare const CONTRACT_ID: "trellis.auth@v1";
-export declare const CONTRACT_DIGEST: "x-9_MjfSThvbn1yc9jAWbaraniKLZ74oUeUqqtZijXQ";
+export declare const CONTRACT_DIGEST: "1YrFqkuEcvzJykFCGnDkhNE4ot_Lbt0T1QBDHabTHMo";
 export type AuthCapabilitiesListInput = {
     limit: number;
     offset?: number;
@@ -1808,6 +1809,13 @@ 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: {
@@ -1815,6 +1823,10 @@ export type AuthServiceInstancesDisableOutput = {
                         };
                         progress: boolean;
                         publishPrefix: string;
+                        queue?: {
+                            maxQueuedPerKey: number;
+                            whenFull: "reject" | "coalesce" | "replace-oldest";
+                        };
                         queueType: string;
                         result?: {
                             schema: string;
@@ -1878,6 +1890,13 @@ 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: {
@@ -1885,6 +1904,10 @@ export type AuthServiceInstancesEnableOutput = {
                         };
                         progress: boolean;
                         publishPrefix: string;
+                        queue?: {
+                            maxQueuedPerKey: number;
+                            whenFull: "reject" | "coalesce" | "replace-oldest";
+                        };
                         queueType: string;
                         result?: {
                             schema: string;
@@ -1952,6 +1975,13 @@ 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: {
@@ -1959,6 +1989,10 @@ export type AuthServiceInstancesListOutput = {
                         };
                         progress: boolean;
                         publishPrefix: string;
+                        queue?: {
+                            maxQueuedPerKey: number;
+                            whenFull: "reject" | "coalesce" | "replace-oldest";
+                        };
                         queueType: string;
                         result?: {
                             schema: string;
@@ -2026,6 +2060,13 @@ 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: {
@@ -2033,6 +2074,10 @@ export type AuthServiceInstancesProvisionOutput = {
                         };
                         progress: boolean;
                         publishPrefix: string;
+                        queue?: {
+                            maxQueuedPerKey: number;
+                            whenFull: "reject" | "coalesce" | "replace-oldest";
+                        };
                         queueType: string;
                         result?: {
                             schema: string;
@@ -2351,39 +2396,49 @@ export type AuthDeviceUserAuthoritiesResolveOutput = {
     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;
 };
+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;
 };
+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;
 };
+export type AuthConnectionsOpenedEventMessage = TrellisEventMessage<AuthConnectionsOpenedEvent>;
+export type AuthConnectionsOpenedEventHandler = (args: {
+    event: AuthConnectionsOpenedEvent;
+    context: EventListenerContext;
+    client: HandlerClient;
+}) => MaybeAsync<void, BaseError>;
 export type AuthDeviceUserAuthoritiesApprovedEvent = {
     approvedAt: string;
     approvedBy: {
@@ -2411,6 +2466,12 @@ 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;
     flowId: string;
@@ -2427,6 +2488,12 @@ 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;
     flowId?: string;
@@ -2444,6 +2511,12 @@ 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;
     flowId: string;
@@ -2461,17 +2534,24 @@ export type AuthDeviceUserAuthoritiesReviewRequestedEvent = {
     };
     reviewId: string;
 };
+export type AuthDeviceUserAuthoritiesReviewRequestedEventMessage = TrellisEventMessage<AuthDeviceUserAuthoritiesReviewRequestedEvent>;
+export type AuthDeviceUserAuthoritiesReviewRequestedEventHandler = (args: {
+    event: AuthDeviceUserAuthoritiesReviewRequestedEvent;
+    context: EventListenerContext;
+    client: HandlerClient;
+}) => MaybeAsync<void, BaseError>;
 export type AuthSessionsRevokedEvent = {
-    header: {
-        id: string;
-        time: string;
-    };
-} & {
     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": {
         input: AuthCapabilitiesListInput;
@@ -2738,72 +2818,468 @@ export interface RpcMap {
         output: AuthUsersUpdateOutput;
     };
 }
-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;