diff --git a/server/routerlicious/packages/services-client/api-report/server-services-client.api.md b/server/routerlicious/packages/services-client/api-report/server-services-client.api.md
index f36462930eed..7b3452dbd0be 100644
--- a/server/routerlicious/packages/services-client/api-report/server-services-client.api.md
+++ b/server/routerlicious/packages/services-client/api-report/server-services-client.api.md
@@ -395,7 +395,8 @@ export interface INormalizedWholeSummary {
 
 // @internal
 export enum InternalErrorCode {
-    ClusterDraining = "ClusterDraining"
+    ClusterDraining = "ClusterDraining",
+    TokenRevoked = "TokenRevoked"
 }
 
 // @internal
diff --git a/server/routerlicious/packages/services-client/src/error.ts b/server/routerlicious/packages/services-client/src/error.ts
index 9934757454d3..d92bf177108a 100644
--- a/server/routerlicious/packages/services-client/src/error.ts
+++ b/server/routerlicious/packages/services-client/src/error.ts
@@ -12,6 +12,11 @@ export enum InternalErrorCode {
 	 * The cluster is under draining.
 	 */
 	ClusterDraining = "ClusterDraining",
+
+	/**
+	 * The token has been revoked.
+	 */
+	TokenRevoked = "TokenRevoked",
 }
 
 /**
diff --git a/server/routerlicious/packages/services/src/test/types/validateServerServicesPrevious.generated.ts b/server/routerlicious/packages/services/src/test/types/validateServerServicesPrevious.generated.ts
index aab198a5ffa0..63e97bae6a4b 100644
--- a/server/routerlicious/packages/services/src/test/types/validateServerServicesPrevious.generated.ts
+++ b/server/routerlicious/packages/services/src/test/types/validateServerServicesPrevious.generated.ts
@@ -23,6 +23,30 @@ type TypeOnly<T> = T extends number
 			[P in keyof T]: TypeOnly<T[P]>;
 	  };
 
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "ClassDeclaration_BasicWebServerFactory": {"forwardCompat": false}
+*/
+declare function get_old_ClassDeclaration_BasicWebServerFactory():
+    TypeOnly<old.BasicWebServerFactory>;
+declare function use_current_ClassDeclaration_BasicWebServerFactory(
+    use: TypeOnly<current.BasicWebServerFactory>): void;
+use_current_ClassDeclaration_BasicWebServerFactory(
+    get_old_ClassDeclaration_BasicWebServerFactory());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "ClassDeclaration_BasicWebServerFactory": {"backCompat": false}
+*/
+declare function get_current_ClassDeclaration_BasicWebServerFactory():
+    TypeOnly<current.BasicWebServerFactory>;
+declare function use_old_ClassDeclaration_BasicWebServerFactory(
+    use: TypeOnly<old.BasicWebServerFactory>): void;
+use_old_ClassDeclaration_BasicWebServerFactory(
+    get_current_ClassDeclaration_BasicWebServerFactory());
+
 /*
 * Validate forward compat by using old type in place of current type
 * If breaking change required, add in package.json under typeValidation.broken:
@@ -119,6 +143,198 @@ declare function use_old_ClassDeclaration_DocumentManager(
 use_old_ClassDeclaration_DocumentManager(
     get_current_ClassDeclaration_DocumentManager());
 
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "ClassDeclaration_DocumentStorage": {"forwardCompat": false}
+*/
+declare function get_old_ClassDeclaration_DocumentStorage():
+    TypeOnly<old.DocumentStorage>;
+declare function use_current_ClassDeclaration_DocumentStorage(
+    use: TypeOnly<current.DocumentStorage>): void;
+use_current_ClassDeclaration_DocumentStorage(
+    get_old_ClassDeclaration_DocumentStorage());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "ClassDeclaration_DocumentStorage": {"backCompat": false}
+*/
+declare function get_current_ClassDeclaration_DocumentStorage():
+    TypeOnly<current.DocumentStorage>;
+declare function use_old_ClassDeclaration_DocumentStorage(
+    use: TypeOnly<old.DocumentStorage>): void;
+use_old_ClassDeclaration_DocumentStorage(
+    get_current_ClassDeclaration_DocumentStorage());
+
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "ClassDeclaration_HttpServer": {"forwardCompat": false}
+*/
+declare function get_old_ClassDeclaration_HttpServer():
+    TypeOnly<old.HttpServer>;
+declare function use_current_ClassDeclaration_HttpServer(
+    use: TypeOnly<current.HttpServer>): void;
+use_current_ClassDeclaration_HttpServer(
+    get_old_ClassDeclaration_HttpServer());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "ClassDeclaration_HttpServer": {"backCompat": false}
+*/
+declare function get_current_ClassDeclaration_HttpServer():
+    TypeOnly<current.HttpServer>;
+declare function use_old_ClassDeclaration_HttpServer(
+    use: TypeOnly<old.HttpServer>): void;
+use_old_ClassDeclaration_HttpServer(
+    get_current_ClassDeclaration_HttpServer());
+
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "InterfaceDeclaration_IHttpServerConfig": {"forwardCompat": false}
+*/
+declare function get_old_InterfaceDeclaration_IHttpServerConfig():
+    TypeOnly<old.IHttpServerConfig>;
+declare function use_current_InterfaceDeclaration_IHttpServerConfig(
+    use: TypeOnly<current.IHttpServerConfig>): void;
+use_current_InterfaceDeclaration_IHttpServerConfig(
+    get_old_InterfaceDeclaration_IHttpServerConfig());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "InterfaceDeclaration_IHttpServerConfig": {"backCompat": false}
+*/
+declare function get_current_InterfaceDeclaration_IHttpServerConfig():
+    TypeOnly<current.IHttpServerConfig>;
+declare function use_old_InterfaceDeclaration_IHttpServerConfig(
+    use: TypeOnly<old.IHttpServerConfig>): void;
+use_old_InterfaceDeclaration_IHttpServerConfig(
+    get_current_InterfaceDeclaration_IHttpServerConfig());
+
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "InterfaceDeclaration_INodeClusterConfig": {"forwardCompat": false}
+*/
+declare function get_old_InterfaceDeclaration_INodeClusterConfig():
+    TypeOnly<old.INodeClusterConfig>;
+declare function use_current_InterfaceDeclaration_INodeClusterConfig(
+    use: TypeOnly<current.INodeClusterConfig>): void;
+use_current_InterfaceDeclaration_INodeClusterConfig(
+    get_old_InterfaceDeclaration_INodeClusterConfig());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "InterfaceDeclaration_INodeClusterConfig": {"backCompat": false}
+*/
+declare function get_current_InterfaceDeclaration_INodeClusterConfig():
+    TypeOnly<current.INodeClusterConfig>;
+declare function use_old_InterfaceDeclaration_INodeClusterConfig(
+    use: TypeOnly<old.INodeClusterConfig>): void;
+use_old_InterfaceDeclaration_INodeClusterConfig(
+    get_current_InterfaceDeclaration_INodeClusterConfig());
+
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "InterfaceDeclaration_ISocketIoRedisConnection": {"forwardCompat": false}
+*/
+declare function get_old_InterfaceDeclaration_ISocketIoRedisConnection():
+    TypeOnly<old.ISocketIoRedisConnection>;
+declare function use_current_InterfaceDeclaration_ISocketIoRedisConnection(
+    use: TypeOnly<current.ISocketIoRedisConnection>): void;
+use_current_InterfaceDeclaration_ISocketIoRedisConnection(
+    get_old_InterfaceDeclaration_ISocketIoRedisConnection());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "InterfaceDeclaration_ISocketIoRedisConnection": {"backCompat": false}
+*/
+declare function get_current_InterfaceDeclaration_ISocketIoRedisConnection():
+    TypeOnly<current.ISocketIoRedisConnection>;
+declare function use_old_InterfaceDeclaration_ISocketIoRedisConnection(
+    use: TypeOnly<old.ISocketIoRedisConnection>): void;
+use_old_InterfaceDeclaration_ISocketIoRedisConnection(
+    get_current_InterfaceDeclaration_ISocketIoRedisConnection());
+
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "InterfaceDeclaration_ISocketIoRedisOptions": {"forwardCompat": false}
+*/
+declare function get_old_InterfaceDeclaration_ISocketIoRedisOptions():
+    TypeOnly<old.ISocketIoRedisOptions>;
+declare function use_current_InterfaceDeclaration_ISocketIoRedisOptions(
+    use: TypeOnly<current.ISocketIoRedisOptions>): void;
+use_current_InterfaceDeclaration_ISocketIoRedisOptions(
+    get_old_InterfaceDeclaration_ISocketIoRedisOptions());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "InterfaceDeclaration_ISocketIoRedisOptions": {"backCompat": false}
+*/
+declare function get_current_InterfaceDeclaration_ISocketIoRedisOptions():
+    TypeOnly<current.ISocketIoRedisOptions>;
+declare function use_old_InterfaceDeclaration_ISocketIoRedisOptions(
+    use: TypeOnly<old.ISocketIoRedisOptions>): void;
+use_old_InterfaceDeclaration_ISocketIoRedisOptions(
+    get_current_InterfaceDeclaration_ISocketIoRedisOptions());
+
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "InterfaceDeclaration_ISocketIoRedisSubscriptionConnection": {"forwardCompat": false}
+*/
+declare function get_old_InterfaceDeclaration_ISocketIoRedisSubscriptionConnection():
+    TypeOnly<old.ISocketIoRedisSubscriptionConnection>;
+declare function use_current_InterfaceDeclaration_ISocketIoRedisSubscriptionConnection(
+    use: TypeOnly<current.ISocketIoRedisSubscriptionConnection>): void;
+use_current_InterfaceDeclaration_ISocketIoRedisSubscriptionConnection(
+    get_old_InterfaceDeclaration_ISocketIoRedisSubscriptionConnection());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "InterfaceDeclaration_ISocketIoRedisSubscriptionConnection": {"backCompat": false}
+*/
+declare function get_current_InterfaceDeclaration_ISocketIoRedisSubscriptionConnection():
+    TypeOnly<current.ISocketIoRedisSubscriptionConnection>;
+declare function use_old_InterfaceDeclaration_ISocketIoRedisSubscriptionConnection(
+    use: TypeOnly<old.ISocketIoRedisSubscriptionConnection>): void;
+use_old_InterfaceDeclaration_ISocketIoRedisSubscriptionConnection(
+    get_current_InterfaceDeclaration_ISocketIoRedisSubscriptionConnection());
+
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "VariableDeclaration_IsEphemeralContainer": {"forwardCompat": false}
+*/
+declare function get_old_VariableDeclaration_IsEphemeralContainer():
+    TypeOnly<typeof old.IsEphemeralContainer>;
+declare function use_current_VariableDeclaration_IsEphemeralContainer(
+    use: TypeOnly<typeof current.IsEphemeralContainer>): void;
+use_current_VariableDeclaration_IsEphemeralContainer(
+    get_old_VariableDeclaration_IsEphemeralContainer());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "VariableDeclaration_IsEphemeralContainer": {"backCompat": false}
+*/
+declare function get_current_VariableDeclaration_IsEphemeralContainer():
+    TypeOnly<typeof current.IsEphemeralContainer>;
+declare function use_old_VariableDeclaration_IsEphemeralContainer(
+    use: TypeOnly<typeof old.IsEphemeralContainer>): void;
+use_old_VariableDeclaration_IsEphemeralContainer(
+    get_current_VariableDeclaration_IsEphemeralContainer());
+
 /*
 * Validate forward compat by using old type in place of current type
 * If breaking change required, add in package.json under typeValidation.broken:
@@ -215,6 +431,30 @@ declare function use_old_ClassDeclaration_NodeAllowList(
 use_old_ClassDeclaration_NodeAllowList(
     get_current_ClassDeclaration_NodeAllowList());
 
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "ClassDeclaration_NodeClusterWebServerFactory": {"forwardCompat": false}
+*/
+declare function get_old_ClassDeclaration_NodeClusterWebServerFactory():
+    TypeOnly<old.NodeClusterWebServerFactory>;
+declare function use_current_ClassDeclaration_NodeClusterWebServerFactory(
+    use: TypeOnly<current.NodeClusterWebServerFactory>): void;
+use_current_ClassDeclaration_NodeClusterWebServerFactory(
+    get_old_ClassDeclaration_NodeClusterWebServerFactory());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "ClassDeclaration_NodeClusterWebServerFactory": {"backCompat": false}
+*/
+declare function get_current_ClassDeclaration_NodeClusterWebServerFactory():
+    TypeOnly<current.NodeClusterWebServerFactory>;
+declare function use_old_ClassDeclaration_NodeClusterWebServerFactory(
+    use: TypeOnly<old.NodeClusterWebServerFactory>): void;
+use_old_ClassDeclaration_NodeClusterWebServerFactory(
+    get_current_ClassDeclaration_NodeClusterWebServerFactory());
+
 /*
 * Validate forward compat by using old type in place of current type
 * If breaking change required, add in package.json under typeValidation.broken:
@@ -263,6 +503,30 @@ declare function use_old_ClassDeclaration_RedisCache(
 use_old_ClassDeclaration_RedisCache(
     get_current_ClassDeclaration_RedisCache());
 
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "ClassDeclaration_RedisSocketIoAdapter": {"forwardCompat": false}
+*/
+declare function get_old_ClassDeclaration_RedisSocketIoAdapter():
+    TypeOnly<old.RedisSocketIoAdapter>;
+declare function use_current_ClassDeclaration_RedisSocketIoAdapter(
+    use: TypeOnly<current.RedisSocketIoAdapter>): void;
+use_current_ClassDeclaration_RedisSocketIoAdapter(
+    get_old_ClassDeclaration_RedisSocketIoAdapter());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "ClassDeclaration_RedisSocketIoAdapter": {"backCompat": false}
+*/
+declare function get_current_ClassDeclaration_RedisSocketIoAdapter():
+    TypeOnly<current.RedisSocketIoAdapter>;
+declare function use_old_ClassDeclaration_RedisSocketIoAdapter(
+    use: TypeOnly<old.RedisSocketIoAdapter>): void;
+use_old_ClassDeclaration_RedisSocketIoAdapter(
+    get_current_ClassDeclaration_RedisSocketIoAdapter());
+
 /*
 * Validate forward compat by using old type in place of current type
 * If breaking change required, add in package.json under typeValidation.broken:
@@ -287,6 +551,54 @@ declare function use_old_ClassDeclaration_RedisThrottleAndUsageStorageManager(
 use_old_ClassDeclaration_RedisThrottleAndUsageStorageManager(
     get_current_ClassDeclaration_RedisThrottleAndUsageStorageManager());
 
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "TypeAliasDeclaration_RequestListener": {"forwardCompat": false}
+*/
+declare function get_old_TypeAliasDeclaration_RequestListener():
+    TypeOnly<old.RequestListener>;
+declare function use_current_TypeAliasDeclaration_RequestListener(
+    use: TypeOnly<current.RequestListener>): void;
+use_current_TypeAliasDeclaration_RequestListener(
+    get_old_TypeAliasDeclaration_RequestListener());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "TypeAliasDeclaration_RequestListener": {"backCompat": false}
+*/
+declare function get_current_TypeAliasDeclaration_RequestListener():
+    TypeOnly<current.RequestListener>;
+declare function use_old_TypeAliasDeclaration_RequestListener(
+    use: TypeOnly<old.RequestListener>): void;
+use_old_TypeAliasDeclaration_RequestListener(
+    get_current_TypeAliasDeclaration_RequestListener());
+
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "ClassDeclaration_RestLessServer": {"forwardCompat": false}
+*/
+declare function get_old_ClassDeclaration_RestLessServer():
+    TypeOnly<old.RestLessServer>;
+declare function use_current_ClassDeclaration_RestLessServer(
+    use: TypeOnly<current.RestLessServer>): void;
+use_current_ClassDeclaration_RestLessServer(
+    get_old_ClassDeclaration_RestLessServer());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "ClassDeclaration_RestLessServer": {"backCompat": false}
+*/
+declare function get_current_ClassDeclaration_RestLessServer():
+    TypeOnly<current.RestLessServer>;
+declare function use_old_ClassDeclaration_RestLessServer(
+    use: TypeOnly<old.RestLessServer>): void;
+use_old_ClassDeclaration_RestLessServer(
+    get_current_ClassDeclaration_RestLessServer());
+
 /*
 * Validate forward compat by using old type in place of current type
 * If breaking change required, add in package.json under typeValidation.broken:
@@ -311,6 +623,30 @@ declare function use_old_ClassDeclaration_SecretManager(
 use_old_ClassDeclaration_SecretManager(
     get_current_ClassDeclaration_SecretManager());
 
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "ClassDeclaration_SocketIoNodeClusterWebServerFactory": {"forwardCompat": false}
+*/
+declare function get_old_ClassDeclaration_SocketIoNodeClusterWebServerFactory():
+    TypeOnly<old.SocketIoNodeClusterWebServerFactory>;
+declare function use_current_ClassDeclaration_SocketIoNodeClusterWebServerFactory(
+    use: TypeOnly<current.SocketIoNodeClusterWebServerFactory>): void;
+use_current_ClassDeclaration_SocketIoNodeClusterWebServerFactory(
+    get_old_ClassDeclaration_SocketIoNodeClusterWebServerFactory());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "ClassDeclaration_SocketIoNodeClusterWebServerFactory": {"backCompat": false}
+*/
+declare function get_current_ClassDeclaration_SocketIoNodeClusterWebServerFactory():
+    TypeOnly<current.SocketIoNodeClusterWebServerFactory>;
+declare function use_old_ClassDeclaration_SocketIoNodeClusterWebServerFactory(
+    use: TypeOnly<old.SocketIoNodeClusterWebServerFactory>): void;
+use_old_ClassDeclaration_SocketIoNodeClusterWebServerFactory(
+    get_current_ClassDeclaration_SocketIoNodeClusterWebServerFactory());
+
 /*
 * Validate forward compat by using old type in place of current type
 * If breaking change required, add in package.json under typeValidation.broken:
@@ -359,6 +695,30 @@ declare function use_old_ClassDeclaration_SocketIoRedisTopic(
 use_old_ClassDeclaration_SocketIoRedisTopic(
     get_current_ClassDeclaration_SocketIoRedisTopic());
 
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "ClassDeclaration_SocketIoWebServerFactory": {"forwardCompat": false}
+*/
+declare function get_old_ClassDeclaration_SocketIoWebServerFactory():
+    TypeOnly<old.SocketIoWebServerFactory>;
+declare function use_current_ClassDeclaration_SocketIoWebServerFactory(
+    use: TypeOnly<current.SocketIoWebServerFactory>): void;
+use_current_ClassDeclaration_SocketIoWebServerFactory(
+    get_old_ClassDeclaration_SocketIoWebServerFactory());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "ClassDeclaration_SocketIoWebServerFactory": {"backCompat": false}
+*/
+declare function get_current_ClassDeclaration_SocketIoWebServerFactory():
+    TypeOnly<current.SocketIoWebServerFactory>;
+declare function use_old_ClassDeclaration_SocketIoWebServerFactory(
+    use: TypeOnly<old.SocketIoWebServerFactory>): void;
+use_old_ClassDeclaration_SocketIoWebServerFactory(
+    get_current_ClassDeclaration_SocketIoWebServerFactory());
+
 /*
 * Validate forward compat by using old type in place of current type
 * If breaking change required, add in package.json under typeValidation.broken:
@@ -479,6 +839,102 @@ declare function use_old_ClassDeclaration_ThrottlerHelper(
 use_old_ClassDeclaration_ThrottlerHelper(
     get_current_ClassDeclaration_ThrottlerHelper());
 
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "ClassDeclaration_WebServer": {"forwardCompat": false}
+*/
+declare function get_old_ClassDeclaration_WebServer():
+    TypeOnly<old.WebServer>;
+declare function use_current_ClassDeclaration_WebServer(
+    use: TypeOnly<current.WebServer>): void;
+use_current_ClassDeclaration_WebServer(
+    get_old_ClassDeclaration_WebServer());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "ClassDeclaration_WebServer": {"backCompat": false}
+*/
+declare function get_current_ClassDeclaration_WebServer():
+    TypeOnly<current.WebServer>;
+declare function use_old_ClassDeclaration_WebServer(
+    use: TypeOnly<old.WebServer>): void;
+use_old_ClassDeclaration_WebServer(
+    get_current_ClassDeclaration_WebServer());
+
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "ClassDeclaration_WholeSummaryReadGitManager": {"forwardCompat": false}
+*/
+declare function get_old_ClassDeclaration_WholeSummaryReadGitManager():
+    TypeOnly<old.WholeSummaryReadGitManager>;
+declare function use_current_ClassDeclaration_WholeSummaryReadGitManager(
+    use: TypeOnly<current.WholeSummaryReadGitManager>): void;
+use_current_ClassDeclaration_WholeSummaryReadGitManager(
+    get_old_ClassDeclaration_WholeSummaryReadGitManager());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "ClassDeclaration_WholeSummaryReadGitManager": {"backCompat": false}
+*/
+declare function get_current_ClassDeclaration_WholeSummaryReadGitManager():
+    TypeOnly<current.WholeSummaryReadGitManager>;
+declare function use_old_ClassDeclaration_WholeSummaryReadGitManager(
+    use: TypeOnly<old.WholeSummaryReadGitManager>): void;
+use_old_ClassDeclaration_WholeSummaryReadGitManager(
+    get_current_ClassDeclaration_WholeSummaryReadGitManager());
+
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "ClassDeclaration_WholeSummaryWriteGitManager": {"forwardCompat": false}
+*/
+declare function get_old_ClassDeclaration_WholeSummaryWriteGitManager():
+    TypeOnly<old.WholeSummaryWriteGitManager>;
+declare function use_current_ClassDeclaration_WholeSummaryWriteGitManager(
+    use: TypeOnly<current.WholeSummaryWriteGitManager>): void;
+use_current_ClassDeclaration_WholeSummaryWriteGitManager(
+    get_old_ClassDeclaration_WholeSummaryWriteGitManager());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "ClassDeclaration_WholeSummaryWriteGitManager": {"backCompat": false}
+*/
+declare function get_current_ClassDeclaration_WholeSummaryWriteGitManager():
+    TypeOnly<current.WholeSummaryWriteGitManager>;
+declare function use_old_ClassDeclaration_WholeSummaryWriteGitManager(
+    use: TypeOnly<old.WholeSummaryWriteGitManager>): void;
+use_old_ClassDeclaration_WholeSummaryWriteGitManager(
+    get_current_ClassDeclaration_WholeSummaryWriteGitManager());
+
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "FunctionDeclaration_containsPathTraversal": {"forwardCompat": false}
+*/
+declare function get_old_FunctionDeclaration_containsPathTraversal():
+    TypeOnly<typeof old.containsPathTraversal>;
+declare function use_current_FunctionDeclaration_containsPathTraversal(
+    use: TypeOnly<typeof current.containsPathTraversal>): void;
+use_current_FunctionDeclaration_containsPathTraversal(
+    get_old_FunctionDeclaration_containsPathTraversal());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "FunctionDeclaration_containsPathTraversal": {"backCompat": false}
+*/
+declare function get_current_FunctionDeclaration_containsPathTraversal():
+    TypeOnly<typeof current.containsPathTraversal>;
+declare function use_old_FunctionDeclaration_containsPathTraversal(
+    use: TypeOnly<typeof old.containsPathTraversal>): void;
+use_old_FunctionDeclaration_containsPathTraversal(
+    get_current_FunctionDeclaration_containsPathTraversal());
+
 /*
 * Validate forward compat by using old type in place of current type
 * If breaking change required, add in package.json under typeValidation.broken:
@@ -575,6 +1031,78 @@ declare function use_old_FunctionDeclaration_createProducer(
 use_old_FunctionDeclaration_createProducer(
     get_current_FunctionDeclaration_createProducer());
 
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "VariableDeclaration_decodeHeader": {"forwardCompat": false}
+*/
+declare function get_old_VariableDeclaration_decodeHeader():
+    TypeOnly<typeof old.decodeHeader>;
+declare function use_current_VariableDeclaration_decodeHeader(
+    use: TypeOnly<typeof current.decodeHeader>): void;
+use_current_VariableDeclaration_decodeHeader(
+    get_old_VariableDeclaration_decodeHeader());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "VariableDeclaration_decodeHeader": {"backCompat": false}
+*/
+declare function get_current_VariableDeclaration_decodeHeader():
+    TypeOnly<typeof current.decodeHeader>;
+declare function use_old_VariableDeclaration_decodeHeader(
+    use: TypeOnly<typeof old.decodeHeader>): void;
+use_old_VariableDeclaration_decodeHeader(
+    get_current_VariableDeclaration_decodeHeader());
+
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "VariableDeclaration_defaultErrorMessage": {"forwardCompat": false}
+*/
+declare function get_old_VariableDeclaration_defaultErrorMessage():
+    TypeOnly<typeof old.defaultErrorMessage>;
+declare function use_current_VariableDeclaration_defaultErrorMessage(
+    use: TypeOnly<typeof current.defaultErrorMessage>): void;
+use_current_VariableDeclaration_defaultErrorMessage(
+    get_old_VariableDeclaration_defaultErrorMessage());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "VariableDeclaration_defaultErrorMessage": {"backCompat": false}
+*/
+declare function get_current_VariableDeclaration_defaultErrorMessage():
+    TypeOnly<typeof current.defaultErrorMessage>;
+declare function use_old_VariableDeclaration_defaultErrorMessage(
+    use: TypeOnly<typeof old.defaultErrorMessage>): void;
+use_old_VariableDeclaration_defaultErrorMessage(
+    get_current_VariableDeclaration_defaultErrorMessage());
+
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "FunctionDeclaration_getBooleanParam": {"forwardCompat": false}
+*/
+declare function get_old_FunctionDeclaration_getBooleanParam():
+    TypeOnly<typeof old.getBooleanParam>;
+declare function use_current_FunctionDeclaration_getBooleanParam(
+    use: TypeOnly<typeof current.getBooleanParam>): void;
+use_current_FunctionDeclaration_getBooleanParam(
+    get_old_FunctionDeclaration_getBooleanParam());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "FunctionDeclaration_getBooleanParam": {"backCompat": false}
+*/
+declare function get_current_FunctionDeclaration_getBooleanParam():
+    TypeOnly<typeof current.getBooleanParam>;
+declare function use_old_FunctionDeclaration_getBooleanParam(
+    use: TypeOnly<typeof old.getBooleanParam>): void;
+use_old_FunctionDeclaration_getBooleanParam(
+    get_current_FunctionDeclaration_getBooleanParam());
+
 /*
 * Validate forward compat by using old type in place of current type
 * If breaking change required, add in package.json under typeValidation.broken:
@@ -598,3 +1126,99 @@ declare function use_old_FunctionDeclaration_getDbFactory(
     use: TypeOnly<typeof old.getDbFactory>): void;
 use_old_FunctionDeclaration_getDbFactory(
     get_current_FunctionDeclaration_getDbFactory());
+
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "FunctionDeclaration_handleResponse": {"forwardCompat": false}
+*/
+declare function get_old_FunctionDeclaration_handleResponse():
+    TypeOnly<typeof old.handleResponse>;
+declare function use_current_FunctionDeclaration_handleResponse(
+    use: TypeOnly<typeof current.handleResponse>): void;
+use_current_FunctionDeclaration_handleResponse(
+    get_old_FunctionDeclaration_handleResponse());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "FunctionDeclaration_handleResponse": {"backCompat": false}
+*/
+declare function get_current_FunctionDeclaration_handleResponse():
+    TypeOnly<typeof current.handleResponse>;
+declare function use_old_FunctionDeclaration_handleResponse(
+    use: TypeOnly<typeof old.handleResponse>): void;
+use_old_FunctionDeclaration_handleResponse(
+    get_current_FunctionDeclaration_handleResponse());
+
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "FunctionDeclaration_run": {"forwardCompat": false}
+*/
+declare function get_old_FunctionDeclaration_run():
+    TypeOnly<typeof old.run>;
+declare function use_current_FunctionDeclaration_run(
+    use: TypeOnly<typeof current.run>): void;
+use_current_FunctionDeclaration_run(
+    get_old_FunctionDeclaration_run());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "FunctionDeclaration_run": {"backCompat": false}
+*/
+declare function get_current_FunctionDeclaration_run():
+    TypeOnly<typeof current.run>;
+declare function use_old_FunctionDeclaration_run(
+    use: TypeOnly<typeof old.run>): void;
+use_old_FunctionDeclaration_run(
+    get_current_FunctionDeclaration_run());
+
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "FunctionDeclaration_runService": {"forwardCompat": false}
+*/
+declare function get_old_FunctionDeclaration_runService():
+    TypeOnly<typeof old.runService>;
+declare function use_current_FunctionDeclaration_runService(
+    use: TypeOnly<typeof current.runService>): void;
+use_current_FunctionDeclaration_runService(
+    get_old_FunctionDeclaration_runService());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "FunctionDeclaration_runService": {"backCompat": false}
+*/
+declare function get_current_FunctionDeclaration_runService():
+    TypeOnly<typeof current.runService>;
+declare function use_old_FunctionDeclaration_runService(
+    use: TypeOnly<typeof old.runService>): void;
+use_old_FunctionDeclaration_runService(
+    get_current_FunctionDeclaration_runService());
+
+/*
+* Validate forward compat by using old type in place of current type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "FunctionDeclaration_validateRequestParams": {"forwardCompat": false}
+*/
+declare function get_old_FunctionDeclaration_validateRequestParams():
+    TypeOnly<typeof old.validateRequestParams>;
+declare function use_current_FunctionDeclaration_validateRequestParams(
+    use: TypeOnly<typeof current.validateRequestParams>): void;
+use_current_FunctionDeclaration_validateRequestParams(
+    get_old_FunctionDeclaration_validateRequestParams());
+
+/*
+* Validate back compat by using current type in place of old type
+* If breaking change required, add in package.json under typeValidation.broken:
+* "FunctionDeclaration_validateRequestParams": {"backCompat": false}
+*/
+declare function get_current_FunctionDeclaration_validateRequestParams():
+    TypeOnly<typeof current.validateRequestParams>;
+declare function use_old_FunctionDeclaration_validateRequestParams(
+    use: TypeOnly<typeof old.validateRequestParams>): void;
+use_old_FunctionDeclaration_validateRequestParams(
+    get_current_FunctionDeclaration_validateRequestParams());