@vercel/sdk 1.10.7 → 1.11.0

package/esm/models/updateprojectdatacacheop.js

@@ -183,13 +183,13 @@ export const UpdateProjectDataCacheProjectsType = {
     Lambdas: "LAMBDAS",
 };
 export const UpdateProjectDataCacheLinkProjectsResponse200Type = {
-    GithubCustomHost: "github-custom-host",
+    Bitbucket: "bitbucket",
 };
 export const UpdateProjectDataCacheLinkProjectsResponseType = {
-    Bitbucket: "bitbucket",
+    Gitlab: "gitlab",
 };
 export const UpdateProjectDataCacheLinkProjectsType = {
-    Gitlab: "gitlab",
+    GithubCustomHost: "github-custom-host",
 };
 export const UpdateProjectDataCacheLinkType = {
     GithubLimited: "github-limited",
@@ -318,7 +318,7 @@ export const UpdateProjectDataCacheProjectsResponseAction = {
     Challenge: "challenge",
     Deny: "deny",
 };
-export const UpdateProjectDataCacheAction = {
+export const UpdateProjectDataCacheProjectsResponse200Action = {
     Log: "log",
     Challenge: "challenge",
     Deny: "deny",
@@ -340,6 +340,57 @@ export const UpdateProjectDataCacheTier = {
     Advanced: "advanced",
     Critical: "critical",
 };
+export const UpdateProjectDataCacheAction = {
+    Blocked: "blocked",
+};
+export const UpdateProjectDataCacheBlockHistoryProjectsResponseAction = {
+    RouteUnblocked: "route-unblocked",
+};
+export const UpdateProjectDataCacheHasProjectsResponseType = {
+    Host: "host",
+};
+export const UpdateProjectDataCacheHasProjectsType = {
+    Header: "header",
+};
+export const UpdateProjectDataCacheHasProjectsKey = {
+    XVercelIpCountry: "x-vercel-ip-country",
+};
+export const UpdateProjectDataCacheRouteAction = {
+    BlockLegalCwc: "block_legal_cwc",
+};
+export const UpdateProjectDataCacheBlockHistoryProjectsAction = {
+    RouteBlocked: "route-blocked",
+};
+export const UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType = {
+    Host: "host",
+};
+export const UpdateProjectDataCacheHasProjectsResponse200Type = {
+    Header: "header",
+};
+export const UpdateProjectDataCacheHasKey = {
+    XVercelIpCountry: "x-vercel-ip-country",
+};
+export const RouteAction = {
+    BlockLegalCwc: "block_legal_cwc",
+};
+export const UpdateProjectDataCacheBlockHistoryAction = {
+    Unblocked: "unblocked",
+};
+export const BlockHistoryAction = {
+    Blocked: "blocked",
+};
+export const UpdateProjectDataCacheHasType = {
+    Host: "host",
+};
+export const HasType = {
+    Header: "header",
+};
+export const Key = {
+    XVercelIpCountry: "x-vercel-ip-country",
+};
+export const InternalRoutesAction = {
+    BlockLegalCwc: "block_legal_cwc",
+};
 /** @internal */
 export const UpdateProjectDataCacheRequestBody$inboundSchema = z.object({
     disabled: z.boolean().optional(),
@@ -2278,12 +2329,12 @@ export function updateProjectDataCacheLinkProjectsResponseDeployHooksFromJSON(js
 /** @internal */
 export const Link5$inboundSchema = z
     .object({
-    org: z.string(),
-    repoOwnerId: z.number().optional(),
-    repo: z.string().optional(),
-    repoId: z.number().optional(),
+    name: z.string(),
+    slug: z.string(),
+    owner: z.string(),
     type: UpdateProjectDataCacheLinkProjectsResponse200Type$inboundSchema,
-    host: z.string(),
+    uuid: z.string(),
+    workspaceUuid: z.string(),
     createdAt: z.number().optional(),
     deployHooks: z.array(z.lazy(() => UpdateProjectDataCacheLinkProjectsResponseDeployHooks$inboundSchema)),
     gitCredentialId: z.string(),
@@ -2293,12 +2344,12 @@ export const Link5$inboundSchema = z
 });
 /** @internal */
 export const Link5$outboundSchema = z.object({
-    org: z.string(),
-    repoOwnerId: z.number().optional(),
-    repo: z.string().optional(),
-    repoId: z.number().optional(),
+    name: z.string(),
+    slug: z.string(),
+    owner: z.string(),
     type: UpdateProjectDataCacheLinkProjectsResponse200Type$outboundSchema,
-    host: z.string(),
+    uuid: z.string(),
+    workspaceUuid: z.string(),
     createdAt: z.number().optional(),
     deployHooks: z.array(z.lazy(() => UpdateProjectDataCacheLinkProjectsResponseDeployHooks$outboundSchema)),
     gitCredentialId: z.string(),
@@ -2375,12 +2426,13 @@ export function updateProjectDataCacheLinkProjectsDeployHooksFromJSON(jsonString
 /** @internal */
 export const Link4$inboundSchema = z
     .object({
-    name: z.string(),
-    slug: z.string(),
-    owner: z.string(),
+    projectId: z.string(),
+    projectName: z.string(),
+    projectNameWithNamespace: z.string(),
+    projectNamespace: z.string(),
+    projectOwnerId: z.number().optional(),
+    projectUrl: z.string(),
     type: UpdateProjectDataCacheLinkProjectsResponseType$inboundSchema,
-    uuid: z.string(),
-    workspaceUuid: z.string(),
     createdAt: z.number().optional(),
     deployHooks: z.array(z.lazy(() => UpdateProjectDataCacheLinkProjectsDeployHooks$inboundSchema)),
     gitCredentialId: z.string(),
@@ -2390,12 +2442,13 @@ export const Link4$inboundSchema = z
 });
 /** @internal */
 export const Link4$outboundSchema = z.object({
-    name: z.string(),
-    slug: z.string(),
-    owner: z.string(),
+    projectId: z.string(),
+    projectName: z.string(),
+    projectNameWithNamespace: z.string(),
+    projectNamespace: z.string(),
+    projectOwnerId: z.number().optional(),
+    projectUrl: z.string(),
     type: UpdateProjectDataCacheLinkProjectsResponseType$outboundSchema,
-    uuid: z.string(),
-    workspaceUuid: z.string(),
     createdAt: z.number().optional(),
     deployHooks: z.array(z.lazy(() => UpdateProjectDataCacheLinkProjectsDeployHooks$outboundSchema)),
     gitCredentialId: z.string(),
@@ -2471,13 +2524,12 @@ export function updateProjectDataCacheLinkDeployHooksFromJSON(jsonString) {
 /** @internal */
 export const Link3$inboundSchema = z
     .object({
-    projectId: z.string(),
-    projectName: z.string(),
-    projectNameWithNamespace: z.string(),
-    projectNamespace: z.string(),
-    projectOwnerId: z.number().optional(),
-    projectUrl: z.string(),
+    org: z.string(),
+    repoOwnerId: z.number().optional(),
+    repo: z.string().optional(),
+    repoId: z.number().optional(),
     type: UpdateProjectDataCacheLinkProjectsType$inboundSchema,
+    host: z.string(),
     createdAt: z.number().optional(),
     deployHooks: z.array(z.lazy(() => UpdateProjectDataCacheLinkDeployHooks$inboundSchema)),
     gitCredentialId: z.string(),
@@ -2487,13 +2539,12 @@ export const Link3$inboundSchema = z
 });
 /** @internal */
 export const Link3$outboundSchema = z.object({
-    projectId: z.string(),
-    projectName: z.string(),
-    projectNameWithNamespace: z.string(),
-    projectNamespace: z.string(),
-    projectOwnerId: z.number().optional(),
-    projectUrl: z.string(),
+    org: z.string(),
+    repoOwnerId: z.number().optional(),
+    repo: z.string().optional(),
+    repoId: z.number().optional(),
     type: UpdateProjectDataCacheLinkProjectsType$outboundSchema,
+    host: z.string(),
     createdAt: z.number().optional(),
     deployHooks: z.array(z.lazy(() => UpdateProjectDataCacheLinkDeployHooks$outboundSchema)),
     gitCredentialId: z.string(),
@@ -2710,17 +2761,17 @@ export function link1FromJSON(jsonString) {
 /** @internal */
 export const Link$inboundSchema = z
     .union([
-    z.lazy(() => Link3$inboundSchema),
     z.lazy(() => Link4$inboundSchema),
     z.lazy(() => Link5$inboundSchema),
+    z.lazy(() => Link3$inboundSchema),
     z.lazy(() => Link1$inboundSchema),
     z.lazy(() => Link2$inboundSchema),
 ]);
 /** @internal */
 export const Link$outboundSchema = z.union([
-    z.lazy(() => Link3$outboundSchema),
     z.lazy(() => Link4$outboundSchema),
     z.lazy(() => Link5$outboundSchema),
+    z.lazy(() => Link3$outboundSchema),
     z.lazy(() => Link1$outboundSchema),
     z.lazy(() => Link2$outboundSchema),
 ]);
@@ -3677,6 +3728,7 @@ export const Permissions$inboundSchema = z.object({
     notificationCustomerBudget: z.array(ACLAction$inboundSchema).optional(),
     notificationStatementOfReasons: z.array(ACLAction$inboundSchema).optional(),
     observabilityConfiguration: z.array(ACLAction$inboundSchema).optional(),
+    alerts: z.array(ACLAction$inboundSchema).optional(),
     observabilityNotebook: z.array(ACLAction$inboundSchema).optional(),
     observabilityFunnel: z.array(ACLAction$inboundSchema).optional(),
     openTelemetryEndpoint: z.array(ACLAction$inboundSchema).optional(),
@@ -3905,6 +3957,7 @@ export const Permissions$outboundSchema = z.object({
     notificationCustomerBudget: z.array(ACLAction$outboundSchema).optional(),
     notificationStatementOfReasons: z.array(ACLAction$outboundSchema).optional(),
     observabilityConfiguration: z.array(ACLAction$outboundSchema).optional(),
+    alerts: z.array(ACLAction$outboundSchema).optional(),
     observabilityNotebook: z.array(ACLAction$outboundSchema).optional(),
     observabilityFunnel: z.array(ACLAction$outboundSchema).optional(),
     openTelemetryEndpoint: z.array(ACLAction$outboundSchema).optional(),
@@ -4567,29 +4620,32 @@ export function botFilterFromJSON(jsonString) {
     return safeParse(jsonString, (x) => BotFilter$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BotFilter' from JSON`);
 }
 /** @internal */
-export const UpdateProjectDataCacheAction$inboundSchema = z.nativeEnum(UpdateProjectDataCacheAction);
+export const UpdateProjectDataCacheProjectsResponse200Action$inboundSchema = z
+    .nativeEnum(UpdateProjectDataCacheProjectsResponse200Action);
 /** @internal */
-export const UpdateProjectDataCacheAction$outboundSchema = UpdateProjectDataCacheAction$inboundSchema;
+export const UpdateProjectDataCacheProjectsResponse200Action$outboundSchema = UpdateProjectDataCacheProjectsResponse200Action$inboundSchema;
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export var UpdateProjectDataCacheAction$;
-(function (UpdateProjectDataCacheAction$) {
-    /** @deprecated use `UpdateProjectDataCacheAction$inboundSchema` instead. */
-    UpdateProjectDataCacheAction$.inboundSchema = UpdateProjectDataCacheAction$inboundSchema;
-    /** @deprecated use `UpdateProjectDataCacheAction$outboundSchema` instead. */
-    UpdateProjectDataCacheAction$.outboundSchema = UpdateProjectDataCacheAction$outboundSchema;
-})(UpdateProjectDataCacheAction$ || (UpdateProjectDataCacheAction$ = {}));
+export var UpdateProjectDataCacheProjectsResponse200Action$;
+(function (UpdateProjectDataCacheProjectsResponse200Action$) {
+    /** @deprecated use `UpdateProjectDataCacheProjectsResponse200Action$inboundSchema` instead. */
+    UpdateProjectDataCacheProjectsResponse200Action$.inboundSchema = UpdateProjectDataCacheProjectsResponse200Action$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheProjectsResponse200Action$outboundSchema` instead. */
+    UpdateProjectDataCacheProjectsResponse200Action$.outboundSchema = UpdateProjectDataCacheProjectsResponse200Action$outboundSchema;
+})(UpdateProjectDataCacheProjectsResponse200Action$ || (UpdateProjectDataCacheProjectsResponse200Action$ = {}));
 /** @internal */
 export const UpdateProjectDataCacheAiBots$inboundSchema = z.object({
     active: z.boolean(),
-    action: UpdateProjectDataCacheAction$inboundSchema.optional(),
+    action: UpdateProjectDataCacheProjectsResponse200Action$inboundSchema
+        .optional(),
 });
 /** @internal */
 export const UpdateProjectDataCacheAiBots$outboundSchema = z.object({
     active: z.boolean(),
-    action: UpdateProjectDataCacheAction$outboundSchema.optional(),
+    action: UpdateProjectDataCacheProjectsResponse200Action$outboundSchema
+        .optional(),
 });
 /**
  * @internal
@@ -4819,159 +4875,1482 @@ export function featuresFromJSON(jsonString) {
     return safeParse(jsonString, (x) => Features$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Features' from JSON`);
 }
 /** @internal */
-export const UpdateProjectDataCacheResponseBody$inboundSchema = z.object({
-    accountId: z.string(),
-    analytics: z.lazy(() => Analytics$inboundSchema).optional(),
-    speedInsights: z.lazy(() => SpeedInsights$inboundSchema).optional(),
-    autoExposeSystemEnvs: z.boolean().optional(),
-    autoAssignCustomDomains: z.boolean().optional(),
-    autoAssignCustomDomainsUpdatedBy: z.string().optional(),
-    buildCommand: z.nullable(z.string()).optional(),
-    commandForIgnoringBuildStep: z.nullable(z.string()).optional(),
-    connectConfigurations: z.nullable(z.array(z.lazy(() => UpdateProjectDataCacheConnectConfigurations$inboundSchema))).optional(),
-    connectConfigurationId: z.nullable(z.string()).optional(),
-    connectBuildsEnabled: z.boolean().optional(),
-    passiveConnectConfigurationId: z.nullable(z.string()).optional(),
-    createdAt: z.number().optional(),
-    customerSupportCodeVisibility: z.boolean().optional(),
-    crons: z.lazy(() => Crons$inboundSchema).optional(),
-    dataCache: z.lazy(() => UpdateProjectDataCacheDataCache$inboundSchema)
-        .optional(),
-    deploymentExpiration: z.nullable(z.lazy(() => DeploymentExpiration$inboundSchema)).optional(),
-    devCommand: z.nullable(z.string()).optional(),
-    directoryListing: z.boolean(),
-    installCommand: z.nullable(z.string()).optional(),
-    env: z.array(z.lazy(() => Env$inboundSchema)).optional(),
-    customEnvironments: z.array(z.lazy(() => CustomEnvironments$inboundSchema))
-        .optional(),
-    framework: z.nullable(UpdateProjectDataCacheFramework$inboundSchema)
-        .optional(),
-    gitForkProtection: z.boolean().optional(),
-    gitLFS: z.boolean().optional(),
-    id: z.string(),
-    ipBuckets: z.array(z.lazy(() => UpdateProjectDataCacheIpBuckets$inboundSchema)).optional(),
-    latestDeployments: z.array(z.lazy(() => LatestDeployments$inboundSchema))
-        .optional(),
-    link: z.union([
-        z.lazy(() => Link3$inboundSchema),
-        z.lazy(() => Link4$inboundSchema),
-        z.lazy(() => Link5$inboundSchema),
-        z.lazy(() => Link1$inboundSchema),
-        z.lazy(() => Link2$inboundSchema),
-    ]).optional(),
-    microfrontends: z.union([
-        z.lazy(() => UpdateProjectDataCacheMicrofrontends1$inboundSchema),
-        z.lazy(() => UpdateProjectDataCacheMicrofrontends2$inboundSchema),
-    ]).optional(),
-    name: z.string(),
-    nodeVersion: UpdateProjectDataCacheNodeVersion$inboundSchema,
-    optionsAllowlist: z.nullable(z.lazy(() => UpdateProjectDataCacheOptionsAllowlist$inboundSchema)).optional(),
-    outputDirectory: z.nullable(z.string()).optional(),
-    passwordProtection: z.nullable(z.lazy(() => UpdateProjectDataCachePasswordProtection$inboundSchema)).optional(),
-    productionDeploymentsFastLane: z.boolean().optional(),
-    publicSource: z.nullable(z.boolean()).optional(),
-    resourceConfig: z.lazy(() => UpdateProjectDataCacheResourceConfig$inboundSchema),
-    rollbackDescription: z.lazy(() => RollbackDescription$inboundSchema)
-        .optional(),
-    rollingRelease: z.nullable(z.lazy(() => RollingRelease$inboundSchema))
-        .optional(),
-    defaultResourceConfig: z.lazy(() => DefaultResourceConfig$inboundSchema),
-    rootDirectory: z.nullable(z.string()).optional(),
-    serverlessFunctionZeroConfigFailover: z.boolean().optional(),
-    skewProtectionBoundaryAt: z.number().optional(),
-    skewProtectionMaxAge: z.number().optional(),
-    skipGitConnectDuringLink: z.boolean().optional(),
-    sourceFilesOutsideRootDirectory: z.boolean().optional(),
-    enableAffectedProjectsDeployments: z.boolean().optional(),
-    ssoProtection: z.nullable(z.lazy(() => UpdateProjectDataCacheSsoProtection$inboundSchema)).optional(),
-    targets: z.record(z.nullable(z.lazy(() => Targets$inboundSchema))).optional(),
-    transferCompletedAt: z.number().optional(),
-    transferStartedAt: z.number().optional(),
-    transferToAccountId: z.string().optional(),
-    transferredFromAccountId: z.string().optional(),
-    updatedAt: z.number().optional(),
-    live: z.boolean().optional(),
-    enablePreviewFeedback: z.nullable(z.boolean()).optional(),
-    enableProductionFeedback: z.nullable(z.boolean()).optional(),
-    permissions: z.lazy(() => Permissions$inboundSchema).optional(),
-    lastRollbackTarget: z.nullable(z.lazy(() => LastRollbackTarget$inboundSchema))
-        .optional(),
-    lastAliasRequest: z.nullable(z.lazy(() => LastAliasRequest$inboundSchema))
-        .optional(),
-    protectionBypass: z.record(z.union([
-        z.lazy(() => ProtectionBypass1$inboundSchema),
-        z.lazy(() => ProtectionBypass2$inboundSchema),
-    ])).optional(),
-    hasActiveBranches: z.boolean().optional(),
-    trustedIps: z.nullable(z.union([
-        z.lazy(() => TrustedIps1$inboundSchema),
-        z.lazy(() => TrustedIps2$inboundSchema),
-    ])).optional(),
-    gitComments: z.lazy(() => GitComments$inboundSchema).optional(),
-    gitProviderOptions: z.lazy(() => GitProviderOptions$inboundSchema).optional(),
-    paused: z.boolean().optional(),
-    concurrencyBucketName: z.string().optional(),
-    webAnalytics: z.lazy(() => UpdateProjectDataCacheWebAnalytics$inboundSchema)
-        .optional(),
-    security: z.lazy(() => UpdateProjectDataCacheSecurity$inboundSchema)
-        .optional(),
-    oidcTokenConfig: z.lazy(() => UpdateProjectDataCacheOidcTokenConfig$inboundSchema).optional(),
-    tier: UpdateProjectDataCacheTier$inboundSchema.optional(),
-    features: z.lazy(() => Features$inboundSchema).optional(),
-    v0: z.boolean().optional(),
+export const UpdateProjectDataCacheHistory$inboundSchema = z.object({
+    scanner: z.string(),
+    reason: z.string(),
+    by: z.string(),
+    byId: z.string(),
+    at: z.number(),
 });
 /** @internal */
-export const UpdateProjectDataCacheResponseBody$outboundSchema = z.object({
-    accountId: z.string(),
-    analytics: z.lazy(() => Analytics$outboundSchema).optional(),
-    speedInsights: z.lazy(() => SpeedInsights$outboundSchema).optional(),
-    autoExposeSystemEnvs: z.boolean().optional(),
-    autoAssignCustomDomains: z.boolean().optional(),
-    autoAssignCustomDomainsUpdatedBy: z.string().optional(),
-    buildCommand: z.nullable(z.string()).optional(),
-    commandForIgnoringBuildStep: z.nullable(z.string()).optional(),
-    connectConfigurations: z.nullable(z.array(z.lazy(() => UpdateProjectDataCacheConnectConfigurations$outboundSchema))).optional(),
-    connectConfigurationId: z.nullable(z.string()).optional(),
-    connectBuildsEnabled: z.boolean().optional(),
-    passiveConnectConfigurationId: z.nullable(z.string()).optional(),
-    createdAt: z.number().optional(),
-    customerSupportCodeVisibility: z.boolean().optional(),
-    crons: z.lazy(() => Crons$outboundSchema).optional(),
-    dataCache: z.lazy(() => UpdateProjectDataCacheDataCache$outboundSchema)
-        .optional(),
-    deploymentExpiration: z.nullable(z.lazy(() => DeploymentExpiration$outboundSchema)).optional(),
-    devCommand: z.nullable(z.string()).optional(),
-    directoryListing: z.boolean(),
-    installCommand: z.nullable(z.string()).optional(),
-    env: z.array(z.lazy(() => Env$outboundSchema)).optional(),
-    customEnvironments: z.array(z.lazy(() => CustomEnvironments$outboundSchema))
-        .optional(),
-    framework: z.nullable(UpdateProjectDataCacheFramework$outboundSchema)
-        .optional(),
-    gitForkProtection: z.boolean().optional(),
-    gitLFS: z.boolean().optional(),
-    id: z.string(),
-    ipBuckets: z.array(z.lazy(() => UpdateProjectDataCacheIpBuckets$outboundSchema)).optional(),
-    latestDeployments: z.array(z.lazy(() => LatestDeployments$outboundSchema))
-        .optional(),
-    link: z.union([
-        z.lazy(() => Link3$outboundSchema),
-        z.lazy(() => Link4$outboundSchema),
-        z.lazy(() => Link5$outboundSchema),
-        z.lazy(() => Link1$outboundSchema),
-        z.lazy(() => Link2$outboundSchema),
-    ]).optional(),
-    microfrontends: z.union([
-        z.lazy(() => UpdateProjectDataCacheMicrofrontends1$outboundSchema),
-        z.lazy(() => UpdateProjectDataCacheMicrofrontends2$outboundSchema),
-    ]).optional(),
-    name: z.string(),
-    nodeVersion: UpdateProjectDataCacheNodeVersion$outboundSchema,
-    optionsAllowlist: z.nullable(z.lazy(() => UpdateProjectDataCacheOptionsAllowlist$outboundSchema)).optional(),
-    outputDirectory: z.nullable(z.string()).optional(),
-    passwordProtection: z.nullable(z.lazy(() => UpdateProjectDataCachePasswordProtection$outboundSchema)).optional(),
-    productionDeploymentsFastLane: z.boolean().optional(),
-    publicSource: z.nullable(z.boolean()).optional(),
+export const UpdateProjectDataCacheHistory$outboundSchema = z.object({
+    scanner: z.string(),
+    reason: z.string(),
+    by: z.string(),
+    byId: z.string(),
+    at: z.number(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheHistory$;
+(function (UpdateProjectDataCacheHistory$) {
+    /** @deprecated use `UpdateProjectDataCacheHistory$inboundSchema` instead. */
+    UpdateProjectDataCacheHistory$.inboundSchema = UpdateProjectDataCacheHistory$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheHistory$outboundSchema` instead. */
+    UpdateProjectDataCacheHistory$.outboundSchema = UpdateProjectDataCacheHistory$outboundSchema;
+})(UpdateProjectDataCacheHistory$ || (UpdateProjectDataCacheHistory$ = {}));
+export function updateProjectDataCacheHistoryToJSON(updateProjectDataCacheHistory) {
+    return JSON.stringify(UpdateProjectDataCacheHistory$outboundSchema.parse(updateProjectDataCacheHistory));
+}
+export function updateProjectDataCacheHistoryFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UpdateProjectDataCacheHistory$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UpdateProjectDataCacheHistory' from JSON`);
+}
+/** @internal */
+export const UpdateProjectDataCacheAction$inboundSchema = z.nativeEnum(UpdateProjectDataCacheAction);
+/** @internal */
+export const UpdateProjectDataCacheAction$outboundSchema = UpdateProjectDataCacheAction$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheAction$;
+(function (UpdateProjectDataCacheAction$) {
+    /** @deprecated use `UpdateProjectDataCacheAction$inboundSchema` instead. */
+    UpdateProjectDataCacheAction$.inboundSchema = UpdateProjectDataCacheAction$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheAction$outboundSchema` instead. */
+    UpdateProjectDataCacheAction$.outboundSchema = UpdateProjectDataCacheAction$outboundSchema;
+})(UpdateProjectDataCacheAction$ || (UpdateProjectDataCacheAction$ = {}));
+/** @internal */
+export const Block$inboundSchema = z
+    .object({
+    action: UpdateProjectDataCacheAction$inboundSchema,
+    reason: z.string(),
+    statusCode: z.number(),
+    createdAt: z.number(),
+    caseId: z.string().optional(),
+    actor: z.string().optional(),
+    comment: z.string().optional(),
+    isCascading: z.boolean().optional(),
+});
+/** @internal */
+export const Block$outboundSchema = z.object({
+    action: UpdateProjectDataCacheAction$outboundSchema,
+    reason: z.string(),
+    statusCode: z.number(),
+    createdAt: z.number(),
+    caseId: z.string().optional(),
+    actor: z.string().optional(),
+    comment: z.string().optional(),
+    isCascading: z.boolean().optional(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var Block$;
+(function (Block$) {
+    /** @deprecated use `Block$inboundSchema` instead. */
+    Block$.inboundSchema = Block$inboundSchema;
+    /** @deprecated use `Block$outboundSchema` instead. */
+    Block$.outboundSchema = Block$outboundSchema;
+})(Block$ || (Block$ = {}));
+export function blockToJSON(block) {
+    return JSON.stringify(Block$outboundSchema.parse(block));
+}
+export function blockFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Block$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Block' from JSON`);
+}
+/** @internal */
+export const UpdateProjectDataCacheBlockHistoryProjectsResponseAction$inboundSchema = z.nativeEnum(UpdateProjectDataCacheBlockHistoryProjectsResponseAction);
+/** @internal */
+export const UpdateProjectDataCacheBlockHistoryProjectsResponseAction$outboundSchema = UpdateProjectDataCacheBlockHistoryProjectsResponseAction$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheBlockHistoryProjectsResponseAction$;
+(function (UpdateProjectDataCacheBlockHistoryProjectsResponseAction$) {
+    /** @deprecated use `UpdateProjectDataCacheBlockHistoryProjectsResponseAction$inboundSchema` instead. */
+    UpdateProjectDataCacheBlockHistoryProjectsResponseAction$.inboundSchema = UpdateProjectDataCacheBlockHistoryProjectsResponseAction$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheBlockHistoryProjectsResponseAction$outboundSchema` instead. */
+    UpdateProjectDataCacheBlockHistoryProjectsResponseAction$.outboundSchema = UpdateProjectDataCacheBlockHistoryProjectsResponseAction$outboundSchema;
+})(UpdateProjectDataCacheBlockHistoryProjectsResponseAction$ || (UpdateProjectDataCacheBlockHistoryProjectsResponseAction$ = {}));
+/** @internal */
+export const UpdateProjectDataCacheHasProjectsResponseType$inboundSchema = z
+    .nativeEnum(UpdateProjectDataCacheHasProjectsResponseType);
+/** @internal */
+export const UpdateProjectDataCacheHasProjectsResponseType$outboundSchema = UpdateProjectDataCacheHasProjectsResponseType$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheHasProjectsResponseType$;
+(function (UpdateProjectDataCacheHasProjectsResponseType$) {
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponseType$inboundSchema` instead. */
+    UpdateProjectDataCacheHasProjectsResponseType$.inboundSchema = UpdateProjectDataCacheHasProjectsResponseType$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponseType$outboundSchema` instead. */
+    UpdateProjectDataCacheHasProjectsResponseType$.outboundSchema = UpdateProjectDataCacheHasProjectsResponseType$outboundSchema;
+})(UpdateProjectDataCacheHasProjectsResponseType$ || (UpdateProjectDataCacheHasProjectsResponseType$ = {}));
+/** @internal */
+export const UpdateProjectDataCacheHasProjectsValue$inboundSchema = z.object({
+    eq: z.string(),
+});
+/** @internal */
+export const UpdateProjectDataCacheHasProjectsValue$outboundSchema = z.object({
+    eq: z.string(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheHasProjectsValue$;
+(function (UpdateProjectDataCacheHasProjectsValue$) {
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsValue$inboundSchema` instead. */
+    UpdateProjectDataCacheHasProjectsValue$.inboundSchema = UpdateProjectDataCacheHasProjectsValue$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsValue$outboundSchema` instead. */
+    UpdateProjectDataCacheHasProjectsValue$.outboundSchema = UpdateProjectDataCacheHasProjectsValue$outboundSchema;
+})(UpdateProjectDataCacheHasProjectsValue$ || (UpdateProjectDataCacheHasProjectsValue$ = {}));
+export function updateProjectDataCacheHasProjectsValueToJSON(updateProjectDataCacheHasProjectsValue) {
+    return JSON.stringify(UpdateProjectDataCacheHasProjectsValue$outboundSchema.parse(updateProjectDataCacheHasProjectsValue));
+}
+export function updateProjectDataCacheHasProjectsValueFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UpdateProjectDataCacheHasProjectsValue$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UpdateProjectDataCacheHasProjectsValue' from JSON`);
+}
+/** @internal */
+export const UpdateProjectDataCacheHas2$inboundSchema = z.object({
+    type: UpdateProjectDataCacheHasProjectsResponseType$inboundSchema,
+    value: z.lazy(() => UpdateProjectDataCacheHasProjectsValue$inboundSchema),
+});
+/** @internal */
+export const UpdateProjectDataCacheHas2$outboundSchema = z.object({
+    type: UpdateProjectDataCacheHasProjectsResponseType$outboundSchema,
+    value: z.lazy(() => UpdateProjectDataCacheHasProjectsValue$outboundSchema),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheHas2$;
+(function (UpdateProjectDataCacheHas2$) {
+    /** @deprecated use `UpdateProjectDataCacheHas2$inboundSchema` instead. */
+    UpdateProjectDataCacheHas2$.inboundSchema = UpdateProjectDataCacheHas2$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheHas2$outboundSchema` instead. */
+    UpdateProjectDataCacheHas2$.outboundSchema = UpdateProjectDataCacheHas2$outboundSchema;
+})(UpdateProjectDataCacheHas2$ || (UpdateProjectDataCacheHas2$ = {}));
+export function updateProjectDataCacheHas2ToJSON(updateProjectDataCacheHas2) {
+    return JSON.stringify(UpdateProjectDataCacheHas2$outboundSchema.parse(updateProjectDataCacheHas2));
+}
+export function updateProjectDataCacheHas2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UpdateProjectDataCacheHas2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UpdateProjectDataCacheHas2' from JSON`);
+}
+/** @internal */
+export const UpdateProjectDataCacheHasProjectsType$inboundSchema = z.nativeEnum(UpdateProjectDataCacheHasProjectsType);
+/** @internal */
+export const UpdateProjectDataCacheHasProjectsType$outboundSchema = UpdateProjectDataCacheHasProjectsType$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheHasProjectsType$;
+(function (UpdateProjectDataCacheHasProjectsType$) {
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsType$inboundSchema` instead. */
+    UpdateProjectDataCacheHasProjectsType$.inboundSchema = UpdateProjectDataCacheHasProjectsType$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsType$outboundSchema` instead. */
+    UpdateProjectDataCacheHasProjectsType$.outboundSchema = UpdateProjectDataCacheHasProjectsType$outboundSchema;
+})(UpdateProjectDataCacheHasProjectsType$ || (UpdateProjectDataCacheHasProjectsType$ = {}));
+/** @internal */
+export const UpdateProjectDataCacheHasProjectsKey$inboundSchema = z.nativeEnum(UpdateProjectDataCacheHasProjectsKey);
+/** @internal */
+export const UpdateProjectDataCacheHasProjectsKey$outboundSchema = UpdateProjectDataCacheHasProjectsKey$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheHasProjectsKey$;
+(function (UpdateProjectDataCacheHasProjectsKey$) {
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsKey$inboundSchema` instead. */
+    UpdateProjectDataCacheHasProjectsKey$.inboundSchema = UpdateProjectDataCacheHasProjectsKey$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsKey$outboundSchema` instead. */
+    UpdateProjectDataCacheHasProjectsKey$.outboundSchema = UpdateProjectDataCacheHasProjectsKey$outboundSchema;
+})(UpdateProjectDataCacheHasProjectsKey$ || (UpdateProjectDataCacheHasProjectsKey$ = {}));
+/** @internal */
+export const UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$inboundSchema = z.object({
+    eq: z.string(),
+});
+/** @internal */
+export const UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$outboundSchema = z.object({
+    eq: z.string(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$;
+(function (UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$) {
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$inboundSchema` instead. */
+    UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$.inboundSchema = UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$outboundSchema` instead. */
+    UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$.outboundSchema = UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$outboundSchema;
+})(UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$ || (UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$ = {}));
+export function updateProjectDataCacheHasProjectsResponse200ApplicationJSONValueToJSON(updateProjectDataCacheHasProjectsResponse200ApplicationJSONValue) {
+    return JSON.stringify(UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$outboundSchema
+        .parse(updateProjectDataCacheHasProjectsResponse200ApplicationJSONValue));
+}
+export function updateProjectDataCacheHasProjectsResponse200ApplicationJSONValueFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$inboundSchema
+        .parse(JSON.parse(x)), `Failed to parse 'UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue' from JSON`);
+}
+/** @internal */
+export const UpdateProjectDataCacheHas1$inboundSchema = z.object({
+    type: UpdateProjectDataCacheHasProjectsType$inboundSchema,
+    key: UpdateProjectDataCacheHasProjectsKey$inboundSchema,
+    value: z.lazy(() => UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$inboundSchema),
+});
+/** @internal */
+export const UpdateProjectDataCacheHas1$outboundSchema = z.object({
+    type: UpdateProjectDataCacheHasProjectsType$outboundSchema,
+    key: UpdateProjectDataCacheHasProjectsKey$outboundSchema,
+    value: z.lazy(() => UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$outboundSchema),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheHas1$;
+(function (UpdateProjectDataCacheHas1$) {
+    /** @deprecated use `UpdateProjectDataCacheHas1$inboundSchema` instead. */
+    UpdateProjectDataCacheHas1$.inboundSchema = UpdateProjectDataCacheHas1$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheHas1$outboundSchema` instead. */
+    UpdateProjectDataCacheHas1$.outboundSchema = UpdateProjectDataCacheHas1$outboundSchema;
+})(UpdateProjectDataCacheHas1$ || (UpdateProjectDataCacheHas1$ = {}));
+export function updateProjectDataCacheHas1ToJSON(updateProjectDataCacheHas1) {
+    return JSON.stringify(UpdateProjectDataCacheHas1$outboundSchema.parse(updateProjectDataCacheHas1));
+}
+export function updateProjectDataCacheHas1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UpdateProjectDataCacheHas1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UpdateProjectDataCacheHas1' from JSON`);
+}
+/** @internal */
+export const RouteHas$inboundSchema = z.union([
+    z.lazy(() => UpdateProjectDataCacheHas1$inboundSchema),
+    z.lazy(() => UpdateProjectDataCacheHas2$inboundSchema),
+]);
+/** @internal */
+export const RouteHas$outboundSchema = z.union([
+    z.lazy(() => UpdateProjectDataCacheHas1$outboundSchema),
+    z.lazy(() => UpdateProjectDataCacheHas2$outboundSchema),
+]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var RouteHas$;
+(function (RouteHas$) {
+    /** @deprecated use `RouteHas$inboundSchema` instead. */
+    RouteHas$.inboundSchema = RouteHas$inboundSchema;
+    /** @deprecated use `RouteHas$outboundSchema` instead. */
+    RouteHas$.outboundSchema = RouteHas$outboundSchema;
+})(RouteHas$ || (RouteHas$ = {}));
+export function routeHasToJSON(routeHas) {
+    return JSON.stringify(RouteHas$outboundSchema.parse(routeHas));
+}
+export function routeHasFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => RouteHas$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'RouteHas' from JSON`);
+}
+/** @internal */
+export const UpdateProjectDataCacheRouteAction$inboundSchema = z.nativeEnum(UpdateProjectDataCacheRouteAction);
+/** @internal */
+export const UpdateProjectDataCacheRouteAction$outboundSchema = UpdateProjectDataCacheRouteAction$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheRouteAction$;
+(function (UpdateProjectDataCacheRouteAction$) {
+    /** @deprecated use `UpdateProjectDataCacheRouteAction$inboundSchema` instead. */
+    UpdateProjectDataCacheRouteAction$.inboundSchema = UpdateProjectDataCacheRouteAction$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheRouteAction$outboundSchema` instead. */
+    UpdateProjectDataCacheRouteAction$.outboundSchema = UpdateProjectDataCacheRouteAction$outboundSchema;
+})(UpdateProjectDataCacheRouteAction$ || (UpdateProjectDataCacheRouteAction$ = {}));
+/** @internal */
+export const RouteMitigate$inboundSchema = z.object({
+    action: UpdateProjectDataCacheRouteAction$inboundSchema,
+});
+/** @internal */
+export const RouteMitigate$outboundSchema = z.object({
+    action: UpdateProjectDataCacheRouteAction$outboundSchema,
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var RouteMitigate$;
+(function (RouteMitigate$) {
+    /** @deprecated use `RouteMitigate$inboundSchema` instead. */
+    RouteMitigate$.inboundSchema = RouteMitigate$inboundSchema;
+    /** @deprecated use `RouteMitigate$outboundSchema` instead. */
+    RouteMitigate$.outboundSchema = RouteMitigate$outboundSchema;
+})(RouteMitigate$ || (RouteMitigate$ = {}));
+export function routeMitigateToJSON(routeMitigate) {
+    return JSON.stringify(RouteMitigate$outboundSchema.parse(routeMitigate));
+}
+export function routeMitigateFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => RouteMitigate$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'RouteMitigate' from JSON`);
+}
+/** @internal */
+export const UpdateProjectDataCacheRoute2$inboundSchema = z.object({
+    has: z.array(z.union([
+        z.lazy(() => UpdateProjectDataCacheHas1$inboundSchema),
+        z.lazy(() => UpdateProjectDataCacheHas2$inboundSchema),
+    ])),
+    mitigate: z.lazy(() => RouteMitigate$inboundSchema),
+    src: z.string().optional(),
+});
+/** @internal */
+export const UpdateProjectDataCacheRoute2$outboundSchema = z.object({
+    has: z.array(z.union([
+        z.lazy(() => UpdateProjectDataCacheHas1$outboundSchema),
+        z.lazy(() => UpdateProjectDataCacheHas2$outboundSchema),
+    ])),
+    mitigate: z.lazy(() => RouteMitigate$outboundSchema),
+    src: z.string().optional(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheRoute2$;
+(function (UpdateProjectDataCacheRoute2$) {
+    /** @deprecated use `UpdateProjectDataCacheRoute2$inboundSchema` instead. */
+    UpdateProjectDataCacheRoute2$.inboundSchema = UpdateProjectDataCacheRoute2$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheRoute2$outboundSchema` instead. */
+    UpdateProjectDataCacheRoute2$.outboundSchema = UpdateProjectDataCacheRoute2$outboundSchema;
+})(UpdateProjectDataCacheRoute2$ || (UpdateProjectDataCacheRoute2$ = {}));
+export function updateProjectDataCacheRoute2ToJSON(updateProjectDataCacheRoute2) {
+    return JSON.stringify(UpdateProjectDataCacheRoute2$outboundSchema.parse(updateProjectDataCacheRoute2));
+}
+export function updateProjectDataCacheRoute2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UpdateProjectDataCacheRoute2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UpdateProjectDataCacheRoute2' from JSON`);
+}
+/** @internal */
+export const UpdateProjectDataCacheRoute1$inboundSchema = z.object({
+    src: z.string(),
+    status: z.number(),
+});
+/** @internal */
+export const UpdateProjectDataCacheRoute1$outboundSchema = z.object({
+    src: z.string(),
+    status: z.number(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheRoute1$;
+(function (UpdateProjectDataCacheRoute1$) {
+    /** @deprecated use `UpdateProjectDataCacheRoute1$inboundSchema` instead. */
+    UpdateProjectDataCacheRoute1$.inboundSchema = UpdateProjectDataCacheRoute1$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheRoute1$outboundSchema` instead. */
+    UpdateProjectDataCacheRoute1$.outboundSchema = UpdateProjectDataCacheRoute1$outboundSchema;
+})(UpdateProjectDataCacheRoute1$ || (UpdateProjectDataCacheRoute1$ = {}));
+export function updateProjectDataCacheRoute1ToJSON(updateProjectDataCacheRoute1) {
+    return JSON.stringify(UpdateProjectDataCacheRoute1$outboundSchema.parse(updateProjectDataCacheRoute1));
+}
+export function updateProjectDataCacheRoute1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UpdateProjectDataCacheRoute1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UpdateProjectDataCacheRoute1' from JSON`);
+}
+/** @internal */
+export const BlockHistoryRoute$inboundSchema = z.union([
+    z.lazy(() => UpdateProjectDataCacheRoute1$inboundSchema),
+    z.lazy(() => UpdateProjectDataCacheRoute2$inboundSchema),
+]);
+/** @internal */
+export const BlockHistoryRoute$outboundSchema = z.union([
+    z.lazy(() => UpdateProjectDataCacheRoute1$outboundSchema),
+    z.lazy(() => UpdateProjectDataCacheRoute2$outboundSchema),
+]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var BlockHistoryRoute$;
+(function (BlockHistoryRoute$) {
+    /** @deprecated use `BlockHistoryRoute$inboundSchema` instead. */
+    BlockHistoryRoute$.inboundSchema = BlockHistoryRoute$inboundSchema;
+    /** @deprecated use `BlockHistoryRoute$outboundSchema` instead. */
+    BlockHistoryRoute$.outboundSchema = BlockHistoryRoute$outboundSchema;
+})(BlockHistoryRoute$ || (BlockHistoryRoute$ = {}));
+export function blockHistoryRouteToJSON(blockHistoryRoute) {
+    return JSON.stringify(BlockHistoryRoute$outboundSchema.parse(blockHistoryRoute));
+}
+export function blockHistoryRouteFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BlockHistoryRoute$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BlockHistoryRoute' from JSON`);
+}
+/** @internal */
+export const BlockHistory4$inboundSchema = z.object({
+    action: UpdateProjectDataCacheBlockHistoryProjectsResponseAction$inboundSchema,
+    route: z.union([
+        z.lazy(() => UpdateProjectDataCacheRoute1$inboundSchema),
+        z.lazy(() => UpdateProjectDataCacheRoute2$inboundSchema),
+    ]),
+    statusCode: z.number().optional(),
+    createdAt: z.number(),
+    caseId: z.string().optional(),
+    actor: z.string().optional(),
+    comment: z.string().optional(),
+    isCascading: z.boolean().optional(),
+});
+/** @internal */
+export const BlockHistory4$outboundSchema = z.object({
+    action: UpdateProjectDataCacheBlockHistoryProjectsResponseAction$outboundSchema,
+    route: z.union([
+        z.lazy(() => UpdateProjectDataCacheRoute1$outboundSchema),
+        z.lazy(() => UpdateProjectDataCacheRoute2$outboundSchema),
+    ]),
+    statusCode: z.number().optional(),
+    createdAt: z.number(),
+    caseId: z.string().optional(),
+    actor: z.string().optional(),
+    comment: z.string().optional(),
+    isCascading: z.boolean().optional(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var BlockHistory4$;
+(function (BlockHistory4$) {
+    /** @deprecated use `BlockHistory4$inboundSchema` instead. */
+    BlockHistory4$.inboundSchema = BlockHistory4$inboundSchema;
+    /** @deprecated use `BlockHistory4$outboundSchema` instead. */
+    BlockHistory4$.outboundSchema = BlockHistory4$outboundSchema;
+})(BlockHistory4$ || (BlockHistory4$ = {}));
+export function blockHistory4ToJSON(blockHistory4) {
+    return JSON.stringify(BlockHistory4$outboundSchema.parse(blockHistory4));
+}
+export function blockHistory4FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BlockHistory4$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BlockHistory4' from JSON`);
+}
+/** @internal */
+export const UpdateProjectDataCacheBlockHistoryProjectsAction$inboundSchema = z
+    .nativeEnum(UpdateProjectDataCacheBlockHistoryProjectsAction);
+/** @internal */
+export const UpdateProjectDataCacheBlockHistoryProjectsAction$outboundSchema = UpdateProjectDataCacheBlockHistoryProjectsAction$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheBlockHistoryProjectsAction$;
+(function (UpdateProjectDataCacheBlockHistoryProjectsAction$) {
+    /** @deprecated use `UpdateProjectDataCacheBlockHistoryProjectsAction$inboundSchema` instead. */
+    UpdateProjectDataCacheBlockHistoryProjectsAction$.inboundSchema = UpdateProjectDataCacheBlockHistoryProjectsAction$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheBlockHistoryProjectsAction$outboundSchema` instead. */
+    UpdateProjectDataCacheBlockHistoryProjectsAction$.outboundSchema = UpdateProjectDataCacheBlockHistoryProjectsAction$outboundSchema;
+})(UpdateProjectDataCacheBlockHistoryProjectsAction$ || (UpdateProjectDataCacheBlockHistoryProjectsAction$ = {}));
+/** @internal */
+export const UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType$inboundSchema = z.nativeEnum(UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType);
+/** @internal */
+export const UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType$outboundSchema = UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType$;
+(function (UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType$) {
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType$inboundSchema` instead. */
+    UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType$.inboundSchema = UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType$outboundSchema` instead. */
+    UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType$.outboundSchema = UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType$outboundSchema;
+})(UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType$ || (UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType$ = {}));
+/** @internal */
+export const UpdateProjectDataCacheHasProjectsResponse200Value$inboundSchema = z.object({
+    eq: z.string(),
+});
+/** @internal */
+export const UpdateProjectDataCacheHasProjectsResponse200Value$outboundSchema = z.object({
+    eq: z.string(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheHasProjectsResponse200Value$;
+(function (UpdateProjectDataCacheHasProjectsResponse200Value$) {
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponse200Value$inboundSchema` instead. */
+    UpdateProjectDataCacheHasProjectsResponse200Value$.inboundSchema = UpdateProjectDataCacheHasProjectsResponse200Value$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponse200Value$outboundSchema` instead. */
+    UpdateProjectDataCacheHasProjectsResponse200Value$.outboundSchema = UpdateProjectDataCacheHasProjectsResponse200Value$outboundSchema;
+})(UpdateProjectDataCacheHasProjectsResponse200Value$ || (UpdateProjectDataCacheHasProjectsResponse200Value$ = {}));
+export function updateProjectDataCacheHasProjectsResponse200ValueToJSON(updateProjectDataCacheHasProjectsResponse200Value) {
+    return JSON.stringify(UpdateProjectDataCacheHasProjectsResponse200Value$outboundSchema.parse(updateProjectDataCacheHasProjectsResponse200Value));
+}
+export function updateProjectDataCacheHasProjectsResponse200ValueFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UpdateProjectDataCacheHasProjectsResponse200Value$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UpdateProjectDataCacheHasProjectsResponse200Value' from JSON`);
+}
+/** @internal */
+export const UpdateProjectDataCacheHasProjects2$inboundSchema = z.object({
+    type: UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType$inboundSchema,
+    value: z.lazy(() => UpdateProjectDataCacheHasProjectsResponse200Value$inboundSchema),
+});
+/** @internal */
+export const UpdateProjectDataCacheHasProjects2$outboundSchema = z.object({
+    type: UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType$outboundSchema,
+    value: z.lazy(() => UpdateProjectDataCacheHasProjectsResponse200Value$outboundSchema),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheHasProjects2$;
+(function (UpdateProjectDataCacheHasProjects2$) {
+    /** @deprecated use `UpdateProjectDataCacheHasProjects2$inboundSchema` instead. */
+    UpdateProjectDataCacheHasProjects2$.inboundSchema = UpdateProjectDataCacheHasProjects2$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheHasProjects2$outboundSchema` instead. */
+    UpdateProjectDataCacheHasProjects2$.outboundSchema = UpdateProjectDataCacheHasProjects2$outboundSchema;
+})(UpdateProjectDataCacheHasProjects2$ || (UpdateProjectDataCacheHasProjects2$ = {}));
+export function updateProjectDataCacheHasProjects2ToJSON(updateProjectDataCacheHasProjects2) {
+    return JSON.stringify(UpdateProjectDataCacheHasProjects2$outboundSchema.parse(updateProjectDataCacheHasProjects2));
+}
+export function updateProjectDataCacheHasProjects2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UpdateProjectDataCacheHasProjects2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UpdateProjectDataCacheHasProjects2' from JSON`);
+}
+/** @internal */
+export const UpdateProjectDataCacheHasProjectsResponse200Type$inboundSchema = z
+    .nativeEnum(UpdateProjectDataCacheHasProjectsResponse200Type);
+/** @internal */
+export const UpdateProjectDataCacheHasProjectsResponse200Type$outboundSchema = UpdateProjectDataCacheHasProjectsResponse200Type$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheHasProjectsResponse200Type$;
+(function (UpdateProjectDataCacheHasProjectsResponse200Type$) {
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponse200Type$inboundSchema` instead. */
+    UpdateProjectDataCacheHasProjectsResponse200Type$.inboundSchema = UpdateProjectDataCacheHasProjectsResponse200Type$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponse200Type$outboundSchema` instead. */
+    UpdateProjectDataCacheHasProjectsResponse200Type$.outboundSchema = UpdateProjectDataCacheHasProjectsResponse200Type$outboundSchema;
+})(UpdateProjectDataCacheHasProjectsResponse200Type$ || (UpdateProjectDataCacheHasProjectsResponse200Type$ = {}));
+/** @internal */
+export const UpdateProjectDataCacheHasKey$inboundSchema = z.nativeEnum(UpdateProjectDataCacheHasKey);
+/** @internal */
+export const UpdateProjectDataCacheHasKey$outboundSchema = UpdateProjectDataCacheHasKey$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheHasKey$;
+(function (UpdateProjectDataCacheHasKey$) {
+    /** @deprecated use `UpdateProjectDataCacheHasKey$inboundSchema` instead. */
+    UpdateProjectDataCacheHasKey$.inboundSchema = UpdateProjectDataCacheHasKey$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheHasKey$outboundSchema` instead. */
+    UpdateProjectDataCacheHasKey$.outboundSchema = UpdateProjectDataCacheHasKey$outboundSchema;
+})(UpdateProjectDataCacheHasKey$ || (UpdateProjectDataCacheHasKey$ = {}));
+/** @internal */
+export const UpdateProjectDataCacheHasProjectsResponseValue$inboundSchema = z.object({
+    eq: z.string(),
+});
+/** @internal */
+export const UpdateProjectDataCacheHasProjectsResponseValue$outboundSchema = z.object({
+    eq: z.string(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheHasProjectsResponseValue$;
+(function (UpdateProjectDataCacheHasProjectsResponseValue$) {
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponseValue$inboundSchema` instead. */
+    UpdateProjectDataCacheHasProjectsResponseValue$.inboundSchema = UpdateProjectDataCacheHasProjectsResponseValue$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponseValue$outboundSchema` instead. */
+    UpdateProjectDataCacheHasProjectsResponseValue$.outboundSchema = UpdateProjectDataCacheHasProjectsResponseValue$outboundSchema;
+})(UpdateProjectDataCacheHasProjectsResponseValue$ || (UpdateProjectDataCacheHasProjectsResponseValue$ = {}));
+export function updateProjectDataCacheHasProjectsResponseValueToJSON(updateProjectDataCacheHasProjectsResponseValue) {
+    return JSON.stringify(UpdateProjectDataCacheHasProjectsResponseValue$outboundSchema.parse(updateProjectDataCacheHasProjectsResponseValue));
+}
+export function updateProjectDataCacheHasProjectsResponseValueFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UpdateProjectDataCacheHasProjectsResponseValue$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UpdateProjectDataCacheHasProjectsResponseValue' from JSON`);
+}
+/** @internal */
+export const UpdateProjectDataCacheHasProjects1$inboundSchema = z.object({
+    type: UpdateProjectDataCacheHasProjectsResponse200Type$inboundSchema,
+    key: UpdateProjectDataCacheHasKey$inboundSchema,
+    value: z.lazy(() => UpdateProjectDataCacheHasProjectsResponseValue$inboundSchema),
+});
+/** @internal */
+export const UpdateProjectDataCacheHasProjects1$outboundSchema = z.object({
+    type: UpdateProjectDataCacheHasProjectsResponse200Type$outboundSchema,
+    key: UpdateProjectDataCacheHasKey$outboundSchema,
+    value: z.lazy(() => UpdateProjectDataCacheHasProjectsResponseValue$outboundSchema),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheHasProjects1$;
+(function (UpdateProjectDataCacheHasProjects1$) {
+    /** @deprecated use `UpdateProjectDataCacheHasProjects1$inboundSchema` instead. */
+    UpdateProjectDataCacheHasProjects1$.inboundSchema = UpdateProjectDataCacheHasProjects1$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheHasProjects1$outboundSchema` instead. */
+    UpdateProjectDataCacheHasProjects1$.outboundSchema = UpdateProjectDataCacheHasProjects1$outboundSchema;
+})(UpdateProjectDataCacheHasProjects1$ || (UpdateProjectDataCacheHasProjects1$ = {}));
+export function updateProjectDataCacheHasProjects1ToJSON(updateProjectDataCacheHasProjects1) {
+    return JSON.stringify(UpdateProjectDataCacheHasProjects1$outboundSchema.parse(updateProjectDataCacheHasProjects1));
+}
+export function updateProjectDataCacheHasProjects1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UpdateProjectDataCacheHasProjects1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UpdateProjectDataCacheHasProjects1' from JSON`);
+}
+/** @internal */
+export const UpdateProjectDataCacheRouteHas$inboundSchema = z.union([
+    z.lazy(() => UpdateProjectDataCacheHasProjects1$inboundSchema),
+    z.lazy(() => UpdateProjectDataCacheHasProjects2$inboundSchema),
+]);
+/** @internal */
+export const UpdateProjectDataCacheRouteHas$outboundSchema = z.union([
+    z.lazy(() => UpdateProjectDataCacheHasProjects1$outboundSchema),
+    z.lazy(() => UpdateProjectDataCacheHasProjects2$outboundSchema),
+]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheRouteHas$;
+(function (UpdateProjectDataCacheRouteHas$) {
+    /** @deprecated use `UpdateProjectDataCacheRouteHas$inboundSchema` instead. */
+    UpdateProjectDataCacheRouteHas$.inboundSchema = UpdateProjectDataCacheRouteHas$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheRouteHas$outboundSchema` instead. */
+    UpdateProjectDataCacheRouteHas$.outboundSchema = UpdateProjectDataCacheRouteHas$outboundSchema;
+})(UpdateProjectDataCacheRouteHas$ || (UpdateProjectDataCacheRouteHas$ = {}));
+export function updateProjectDataCacheRouteHasToJSON(updateProjectDataCacheRouteHas) {
+    return JSON.stringify(UpdateProjectDataCacheRouteHas$outboundSchema.parse(updateProjectDataCacheRouteHas));
+}
+export function updateProjectDataCacheRouteHasFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UpdateProjectDataCacheRouteHas$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UpdateProjectDataCacheRouteHas' from JSON`);
+}
+/** @internal */
+export const RouteAction$inboundSchema = z
+    .nativeEnum(RouteAction);
+/** @internal */
+export const RouteAction$outboundSchema = RouteAction$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var RouteAction$;
+(function (RouteAction$) {
+    /** @deprecated use `RouteAction$inboundSchema` instead. */
+    RouteAction$.inboundSchema = RouteAction$inboundSchema;
+    /** @deprecated use `RouteAction$outboundSchema` instead. */
+    RouteAction$.outboundSchema = RouteAction$outboundSchema;
+})(RouteAction$ || (RouteAction$ = {}));
+/** @internal */
+export const UpdateProjectDataCacheRouteMitigate$inboundSchema = z.object({
+    action: RouteAction$inboundSchema,
+});
+/** @internal */
+export const UpdateProjectDataCacheRouteMitigate$outboundSchema = z.object({
+    action: RouteAction$outboundSchema,
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheRouteMitigate$;
+(function (UpdateProjectDataCacheRouteMitigate$) {
+    /** @deprecated use `UpdateProjectDataCacheRouteMitigate$inboundSchema` instead. */
+    UpdateProjectDataCacheRouteMitigate$.inboundSchema = UpdateProjectDataCacheRouteMitigate$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheRouteMitigate$outboundSchema` instead. */
+    UpdateProjectDataCacheRouteMitigate$.outboundSchema = UpdateProjectDataCacheRouteMitigate$outboundSchema;
+})(UpdateProjectDataCacheRouteMitigate$ || (UpdateProjectDataCacheRouteMitigate$ = {}));
+export function updateProjectDataCacheRouteMitigateToJSON(updateProjectDataCacheRouteMitigate) {
+    return JSON.stringify(UpdateProjectDataCacheRouteMitigate$outboundSchema.parse(updateProjectDataCacheRouteMitigate));
+}
+export function updateProjectDataCacheRouteMitigateFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UpdateProjectDataCacheRouteMitigate$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UpdateProjectDataCacheRouteMitigate' from JSON`);
+}
+/** @internal */
+export const Route2$inboundSchema = z
+    .object({
+    has: z.array(z.union([
+        z.lazy(() => UpdateProjectDataCacheHasProjects1$inboundSchema),
+        z.lazy(() => UpdateProjectDataCacheHasProjects2$inboundSchema),
+    ])),
+    mitigate: z.lazy(() => UpdateProjectDataCacheRouteMitigate$inboundSchema),
+    src: z.string().optional(),
+});
+/** @internal */
+export const Route2$outboundSchema = z.object({
+    has: z.array(z.union([
+        z.lazy(() => UpdateProjectDataCacheHasProjects1$outboundSchema),
+        z.lazy(() => UpdateProjectDataCacheHasProjects2$outboundSchema),
+    ])),
+    mitigate: z.lazy(() => UpdateProjectDataCacheRouteMitigate$outboundSchema),
+    src: z.string().optional(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var Route2$;
+(function (Route2$) {
+    /** @deprecated use `Route2$inboundSchema` instead. */
+    Route2$.inboundSchema = Route2$inboundSchema;
+    /** @deprecated use `Route2$outboundSchema` instead. */
+    Route2$.outboundSchema = Route2$outboundSchema;
+})(Route2$ || (Route2$ = {}));
+export function route2ToJSON(route2) {
+    return JSON.stringify(Route2$outboundSchema.parse(route2));
+}
+export function route2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Route2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Route2' from JSON`);
+}
+/** @internal */
+export const Route1$inboundSchema = z
+    .object({
+    src: z.string(),
+    status: z.number(),
+});
+/** @internal */
+export const Route1$outboundSchema = z.object({
+    src: z.string(),
+    status: z.number(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var Route1$;
+(function (Route1$) {
+    /** @deprecated use `Route1$inboundSchema` instead. */
+    Route1$.inboundSchema = Route1$inboundSchema;
+    /** @deprecated use `Route1$outboundSchema` instead. */
+    Route1$.outboundSchema = Route1$outboundSchema;
+})(Route1$ || (Route1$ = {}));
+export function route1ToJSON(route1) {
+    return JSON.stringify(Route1$outboundSchema.parse(route1));
+}
+export function route1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Route1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Route1' from JSON`);
+}
+/** @internal */
+export const Route$inboundSchema = z
+    .union([
+    z.lazy(() => Route1$inboundSchema),
+    z.lazy(() => Route2$inboundSchema),
+]);
+/** @internal */
+export const Route$outboundSchema = z.union([
+    z.lazy(() => Route1$outboundSchema),
+    z.lazy(() => Route2$outboundSchema),
+]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var Route$;
+(function (Route$) {
+    /** @deprecated use `Route$inboundSchema` instead. */
+    Route$.inboundSchema = Route$inboundSchema;
+    /** @deprecated use `Route$outboundSchema` instead. */
+    Route$.outboundSchema = Route$outboundSchema;
+})(Route$ || (Route$ = {}));
+export function routeToJSON(route) {
+    return JSON.stringify(Route$outboundSchema.parse(route));
+}
+export function routeFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Route$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Route' from JSON`);
+}
+/** @internal */
+export const BlockHistory3$inboundSchema = z.object({
+    action: UpdateProjectDataCacheBlockHistoryProjectsAction$inboundSchema,
+    route: z.union([
+        z.lazy(() => Route1$inboundSchema),
+        z.lazy(() => Route2$inboundSchema),
+    ]),
+    reason: z.string(),
+    createdAt: z.number(),
+    caseId: z.string().optional(),
+    actor: z.string().optional(),
+    comment: z.string().optional(),
+    isCascading: z.boolean().optional(),
+});
+/** @internal */
+export const BlockHistory3$outboundSchema = z.object({
+    action: UpdateProjectDataCacheBlockHistoryProjectsAction$outboundSchema,
+    route: z.union([
+        z.lazy(() => Route1$outboundSchema),
+        z.lazy(() => Route2$outboundSchema),
+    ]),
+    reason: z.string(),
+    createdAt: z.number(),
+    caseId: z.string().optional(),
+    actor: z.string().optional(),
+    comment: z.string().optional(),
+    isCascading: z.boolean().optional(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var BlockHistory3$;
+(function (BlockHistory3$) {
+    /** @deprecated use `BlockHistory3$inboundSchema` instead. */
+    BlockHistory3$.inboundSchema = BlockHistory3$inboundSchema;
+    /** @deprecated use `BlockHistory3$outboundSchema` instead. */
+    BlockHistory3$.outboundSchema = BlockHistory3$outboundSchema;
+})(BlockHistory3$ || (BlockHistory3$ = {}));
+export function blockHistory3ToJSON(blockHistory3) {
+    return JSON.stringify(BlockHistory3$outboundSchema.parse(blockHistory3));
+}
+export function blockHistory3FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BlockHistory3$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BlockHistory3' from JSON`);
+}
+/** @internal */
+export const UpdateProjectDataCacheBlockHistoryAction$inboundSchema = z
+    .nativeEnum(UpdateProjectDataCacheBlockHistoryAction);
+/** @internal */
+export const UpdateProjectDataCacheBlockHistoryAction$outboundSchema = UpdateProjectDataCacheBlockHistoryAction$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheBlockHistoryAction$;
+(function (UpdateProjectDataCacheBlockHistoryAction$) {
+    /** @deprecated use `UpdateProjectDataCacheBlockHistoryAction$inboundSchema` instead. */
+    UpdateProjectDataCacheBlockHistoryAction$.inboundSchema = UpdateProjectDataCacheBlockHistoryAction$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheBlockHistoryAction$outboundSchema` instead. */
+    UpdateProjectDataCacheBlockHistoryAction$.outboundSchema = UpdateProjectDataCacheBlockHistoryAction$outboundSchema;
+})(UpdateProjectDataCacheBlockHistoryAction$ || (UpdateProjectDataCacheBlockHistoryAction$ = {}));
+/** @internal */
+export const BlockHistory2$inboundSchema = z.object({
+    action: UpdateProjectDataCacheBlockHistoryAction$inboundSchema,
+    createdAt: z.number(),
+    caseId: z.string().optional(),
+    actor: z.string().optional(),
+    comment: z.string().optional(),
+    isCascading: z.boolean().optional(),
+});
+/** @internal */
+export const BlockHistory2$outboundSchema = z.object({
+    action: UpdateProjectDataCacheBlockHistoryAction$outboundSchema,
+    createdAt: z.number(),
+    caseId: z.string().optional(),
+    actor: z.string().optional(),
+    comment: z.string().optional(),
+    isCascading: z.boolean().optional(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var BlockHistory2$;
+(function (BlockHistory2$) {
+    /** @deprecated use `BlockHistory2$inboundSchema` instead. */
+    BlockHistory2$.inboundSchema = BlockHistory2$inboundSchema;
+    /** @deprecated use `BlockHistory2$outboundSchema` instead. */
+    BlockHistory2$.outboundSchema = BlockHistory2$outboundSchema;
+})(BlockHistory2$ || (BlockHistory2$ = {}));
+export function blockHistory2ToJSON(blockHistory2) {
+    return JSON.stringify(BlockHistory2$outboundSchema.parse(blockHistory2));
+}
+export function blockHistory2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BlockHistory2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BlockHistory2' from JSON`);
+}
+/** @internal */
+export const BlockHistoryAction$inboundSchema = z.nativeEnum(BlockHistoryAction);
+/** @internal */
+export const BlockHistoryAction$outboundSchema = BlockHistoryAction$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var BlockHistoryAction$;
+(function (BlockHistoryAction$) {
+    /** @deprecated use `BlockHistoryAction$inboundSchema` instead. */
+    BlockHistoryAction$.inboundSchema = BlockHistoryAction$inboundSchema;
+    /** @deprecated use `BlockHistoryAction$outboundSchema` instead. */
+    BlockHistoryAction$.outboundSchema = BlockHistoryAction$outboundSchema;
+})(BlockHistoryAction$ || (BlockHistoryAction$ = {}));
+/** @internal */
+export const BlockHistory1$inboundSchema = z.object({
+    action: BlockHistoryAction$inboundSchema,
+    reason: z.string(),
+    statusCode: z.number(),
+    createdAt: z.number(),
+    caseId: z.string().optional(),
+    actor: z.string().optional(),
+    comment: z.string().optional(),
+    isCascading: z.boolean().optional(),
+});
+/** @internal */
+export const BlockHistory1$outboundSchema = z.object({
+    action: BlockHistoryAction$outboundSchema,
+    reason: z.string(),
+    statusCode: z.number(),
+    createdAt: z.number(),
+    caseId: z.string().optional(),
+    actor: z.string().optional(),
+    comment: z.string().optional(),
+    isCascading: z.boolean().optional(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var BlockHistory1$;
+(function (BlockHistory1$) {
+    /** @deprecated use `BlockHistory1$inboundSchema` instead. */
+    BlockHistory1$.inboundSchema = BlockHistory1$inboundSchema;
+    /** @deprecated use `BlockHistory1$outboundSchema` instead. */
+    BlockHistory1$.outboundSchema = BlockHistory1$outboundSchema;
+})(BlockHistory1$ || (BlockHistory1$ = {}));
+export function blockHistory1ToJSON(blockHistory1) {
+    return JSON.stringify(BlockHistory1$outboundSchema.parse(blockHistory1));
+}
+export function blockHistory1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BlockHistory1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BlockHistory1' from JSON`);
+}
+/** @internal */
+export const UpdateProjectDataCacheBlockHistory$inboundSchema = z.union([
+    z.lazy(() => BlockHistory1$inboundSchema),
+    z.lazy(() => BlockHistory3$inboundSchema),
+    z.lazy(() => BlockHistory4$inboundSchema),
+    z.lazy(() => BlockHistory2$inboundSchema),
+]);
+/** @internal */
+export const UpdateProjectDataCacheBlockHistory$outboundSchema = z.union([
+    z.lazy(() => BlockHistory1$outboundSchema),
+    z.lazy(() => BlockHistory3$outboundSchema),
+    z.lazy(() => BlockHistory4$outboundSchema),
+    z.lazy(() => BlockHistory2$outboundSchema),
+]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheBlockHistory$;
+(function (UpdateProjectDataCacheBlockHistory$) {
+    /** @deprecated use `UpdateProjectDataCacheBlockHistory$inboundSchema` instead. */
+    UpdateProjectDataCacheBlockHistory$.inboundSchema = UpdateProjectDataCacheBlockHistory$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheBlockHistory$outboundSchema` instead. */
+    UpdateProjectDataCacheBlockHistory$.outboundSchema = UpdateProjectDataCacheBlockHistory$outboundSchema;
+})(UpdateProjectDataCacheBlockHistory$ || (UpdateProjectDataCacheBlockHistory$ = {}));
+export function updateProjectDataCacheBlockHistoryToJSON(updateProjectDataCacheBlockHistory) {
+    return JSON.stringify(UpdateProjectDataCacheBlockHistory$outboundSchema.parse(updateProjectDataCacheBlockHistory));
+}
+export function updateProjectDataCacheBlockHistoryFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UpdateProjectDataCacheBlockHistory$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UpdateProjectDataCacheBlockHistory' from JSON`);
+}
+/** @internal */
+export const UpdateProjectDataCacheAbuse$inboundSchema = z.object({
+    scanner: z.string().optional(),
+    history: z.array(z.lazy(() => UpdateProjectDataCacheHistory$inboundSchema)),
+    updatedAt: z.number(),
+    block: z.lazy(() => Block$inboundSchema).optional(),
+    blockHistory: z.array(z.union([
+        z.lazy(() => BlockHistory1$inboundSchema),
+        z.lazy(() => BlockHistory3$inboundSchema),
+        z.lazy(() => BlockHistory4$inboundSchema),
+        z.lazy(() => BlockHistory2$inboundSchema),
+    ])).optional(),
+});
+/** @internal */
+export const UpdateProjectDataCacheAbuse$outboundSchema = z.object({
+    scanner: z.string().optional(),
+    history: z.array(z.lazy(() => UpdateProjectDataCacheHistory$outboundSchema)),
+    updatedAt: z.number(),
+    block: z.lazy(() => Block$outboundSchema).optional(),
+    blockHistory: z.array(z.union([
+        z.lazy(() => BlockHistory1$outboundSchema),
+        z.lazy(() => BlockHistory3$outboundSchema),
+        z.lazy(() => BlockHistory4$outboundSchema),
+        z.lazy(() => BlockHistory2$outboundSchema),
+    ])).optional(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheAbuse$;
+(function (UpdateProjectDataCacheAbuse$) {
+    /** @deprecated use `UpdateProjectDataCacheAbuse$inboundSchema` instead. */
+    UpdateProjectDataCacheAbuse$.inboundSchema = UpdateProjectDataCacheAbuse$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheAbuse$outboundSchema` instead. */
+    UpdateProjectDataCacheAbuse$.outboundSchema = UpdateProjectDataCacheAbuse$outboundSchema;
+})(UpdateProjectDataCacheAbuse$ || (UpdateProjectDataCacheAbuse$ = {}));
+export function updateProjectDataCacheAbuseToJSON(updateProjectDataCacheAbuse) {
+    return JSON.stringify(UpdateProjectDataCacheAbuse$outboundSchema.parse(updateProjectDataCacheAbuse));
+}
+export function updateProjectDataCacheAbuseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UpdateProjectDataCacheAbuse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UpdateProjectDataCacheAbuse' from JSON`);
+}
+/** @internal */
+export const UpdateProjectDataCacheHasType$inboundSchema = z.nativeEnum(UpdateProjectDataCacheHasType);
+/** @internal */
+export const UpdateProjectDataCacheHasType$outboundSchema = UpdateProjectDataCacheHasType$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheHasType$;
+(function (UpdateProjectDataCacheHasType$) {
+    /** @deprecated use `UpdateProjectDataCacheHasType$inboundSchema` instead. */
+    UpdateProjectDataCacheHasType$.inboundSchema = UpdateProjectDataCacheHasType$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheHasType$outboundSchema` instead. */
+    UpdateProjectDataCacheHasType$.outboundSchema = UpdateProjectDataCacheHasType$outboundSchema;
+})(UpdateProjectDataCacheHasType$ || (UpdateProjectDataCacheHasType$ = {}));
+/** @internal */
+export const HasValue$inboundSchema = z.object({
+    eq: z.string(),
+});
+/** @internal */
+export const HasValue$outboundSchema = z.object({
+    eq: z.string(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var HasValue$;
+(function (HasValue$) {
+    /** @deprecated use `HasValue$inboundSchema` instead. */
+    HasValue$.inboundSchema = HasValue$inboundSchema;
+    /** @deprecated use `HasValue$outboundSchema` instead. */
+    HasValue$.outboundSchema = HasValue$outboundSchema;
+})(HasValue$ || (HasValue$ = {}));
+export function hasValueToJSON(hasValue) {
+    return JSON.stringify(HasValue$outboundSchema.parse(hasValue));
+}
+export function hasValueFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => HasValue$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'HasValue' from JSON`);
+}
+/** @internal */
+export const Has2$inboundSchema = z
+    .object({
+    type: UpdateProjectDataCacheHasType$inboundSchema,
+    value: z.lazy(() => HasValue$inboundSchema),
+});
+/** @internal */
+export const Has2$outboundSchema = z.object({
+    type: UpdateProjectDataCacheHasType$outboundSchema,
+    value: z.lazy(() => HasValue$outboundSchema),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var Has2$;
+(function (Has2$) {
+    /** @deprecated use `Has2$inboundSchema` instead. */
+    Has2$.inboundSchema = Has2$inboundSchema;
+    /** @deprecated use `Has2$outboundSchema` instead. */
+    Has2$.outboundSchema = Has2$outboundSchema;
+})(Has2$ || (Has2$ = {}));
+export function has2ToJSON(has2) {
+    return JSON.stringify(Has2$outboundSchema.parse(has2));
+}
+export function has2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Has2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Has2' from JSON`);
+}
+/** @internal */
+export const HasType$inboundSchema = z
+    .nativeEnum(HasType);
+/** @internal */
+export const HasType$outboundSchema = HasType$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var HasType$;
+(function (HasType$) {
+    /** @deprecated use `HasType$inboundSchema` instead. */
+    HasType$.inboundSchema = HasType$inboundSchema;
+    /** @deprecated use `HasType$outboundSchema` instead. */
+    HasType$.outboundSchema = HasType$outboundSchema;
+})(HasType$ || (HasType$ = {}));
+/** @internal */
+export const Key$inboundSchema = z.nativeEnum(Key);
+/** @internal */
+export const Key$outboundSchema = Key$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var Key$;
+(function (Key$) {
+    /** @deprecated use `Key$inboundSchema` instead. */
+    Key$.inboundSchema = Key$inboundSchema;
+    /** @deprecated use `Key$outboundSchema` instead. */
+    Key$.outboundSchema = Key$outboundSchema;
+})(Key$ || (Key$ = {}));
+/** @internal */
+export const UpdateProjectDataCacheHasValue$inboundSchema = z.object({
+    eq: z.string(),
+});
+/** @internal */
+export const UpdateProjectDataCacheHasValue$outboundSchema = z.object({
+    eq: z.string(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheHasValue$;
+(function (UpdateProjectDataCacheHasValue$) {
+    /** @deprecated use `UpdateProjectDataCacheHasValue$inboundSchema` instead. */
+    UpdateProjectDataCacheHasValue$.inboundSchema = UpdateProjectDataCacheHasValue$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheHasValue$outboundSchema` instead. */
+    UpdateProjectDataCacheHasValue$.outboundSchema = UpdateProjectDataCacheHasValue$outboundSchema;
+})(UpdateProjectDataCacheHasValue$ || (UpdateProjectDataCacheHasValue$ = {}));
+export function updateProjectDataCacheHasValueToJSON(updateProjectDataCacheHasValue) {
+    return JSON.stringify(UpdateProjectDataCacheHasValue$outboundSchema.parse(updateProjectDataCacheHasValue));
+}
+export function updateProjectDataCacheHasValueFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UpdateProjectDataCacheHasValue$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UpdateProjectDataCacheHasValue' from JSON`);
+}
+/** @internal */
+export const Has1$inboundSchema = z
+    .object({
+    type: HasType$inboundSchema,
+    key: Key$inboundSchema,
+    value: z.lazy(() => UpdateProjectDataCacheHasValue$inboundSchema),
+});
+/** @internal */
+export const Has1$outboundSchema = z.object({
+    type: HasType$outboundSchema,
+    key: Key$outboundSchema,
+    value: z.lazy(() => UpdateProjectDataCacheHasValue$outboundSchema),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var Has1$;
+(function (Has1$) {
+    /** @deprecated use `Has1$inboundSchema` instead. */
+    Has1$.inboundSchema = Has1$inboundSchema;
+    /** @deprecated use `Has1$outboundSchema` instead. */
+    Has1$.outboundSchema = Has1$outboundSchema;
+})(Has1$ || (Has1$ = {}));
+export function has1ToJSON(has1) {
+    return JSON.stringify(Has1$outboundSchema.parse(has1));
+}
+export function has1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Has1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Has1' from JSON`);
+}
+/** @internal */
+export const Has$inboundSchema = z.union([z.lazy(() => Has1$inboundSchema), z.lazy(() => Has2$inboundSchema)]);
+/** @internal */
+export const Has$outboundSchema = z
+    .union([
+    z.lazy(() => Has1$outboundSchema),
+    z.lazy(() => Has2$outboundSchema),
+]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var Has$;
+(function (Has$) {
+    /** @deprecated use `Has$inboundSchema` instead. */
+    Has$.inboundSchema = Has$inboundSchema;
+    /** @deprecated use `Has$outboundSchema` instead. */
+    Has$.outboundSchema = Has$outboundSchema;
+})(Has$ || (Has$ = {}));
+export function hasToJSON(has) {
+    return JSON.stringify(Has$outboundSchema.parse(has));
+}
+export function hasFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Has$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Has' from JSON`);
+}
+/** @internal */
+export const InternalRoutesAction$inboundSchema = z.nativeEnum(InternalRoutesAction);
+/** @internal */
+export const InternalRoutesAction$outboundSchema = InternalRoutesAction$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var InternalRoutesAction$;
+(function (InternalRoutesAction$) {
+    /** @deprecated use `InternalRoutesAction$inboundSchema` instead. */
+    InternalRoutesAction$.inboundSchema = InternalRoutesAction$inboundSchema;
+    /** @deprecated use `InternalRoutesAction$outboundSchema` instead. */
+    InternalRoutesAction$.outboundSchema = InternalRoutesAction$outboundSchema;
+})(InternalRoutesAction$ || (InternalRoutesAction$ = {}));
+/** @internal */
+export const UpdateProjectDataCacheInternalRoutesMitigate$inboundSchema = z.object({
+    action: InternalRoutesAction$inboundSchema,
+});
+/** @internal */
+export const UpdateProjectDataCacheInternalRoutesMitigate$outboundSchema = z.object({
+    action: InternalRoutesAction$outboundSchema,
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var UpdateProjectDataCacheInternalRoutesMitigate$;
+(function (UpdateProjectDataCacheInternalRoutesMitigate$) {
+    /** @deprecated use `UpdateProjectDataCacheInternalRoutesMitigate$inboundSchema` instead. */
+    UpdateProjectDataCacheInternalRoutesMitigate$.inboundSchema = UpdateProjectDataCacheInternalRoutesMitigate$inboundSchema;
+    /** @deprecated use `UpdateProjectDataCacheInternalRoutesMitigate$outboundSchema` instead. */
+    UpdateProjectDataCacheInternalRoutesMitigate$.outboundSchema = UpdateProjectDataCacheInternalRoutesMitigate$outboundSchema;
+})(UpdateProjectDataCacheInternalRoutesMitigate$ || (UpdateProjectDataCacheInternalRoutesMitigate$ = {}));
+export function updateProjectDataCacheInternalRoutesMitigateToJSON(updateProjectDataCacheInternalRoutesMitigate) {
+    return JSON.stringify(UpdateProjectDataCacheInternalRoutesMitigate$outboundSchema.parse(updateProjectDataCacheInternalRoutesMitigate));
+}
+export function updateProjectDataCacheInternalRoutesMitigateFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => UpdateProjectDataCacheInternalRoutesMitigate$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'UpdateProjectDataCacheInternalRoutesMitigate' from JSON`);
+}
+/** @internal */
+export const InternalRoutes2$inboundSchema = z.object({
+    has: z.array(z.union([
+        z.lazy(() => Has1$inboundSchema),
+        z.lazy(() => Has2$inboundSchema),
+    ])),
+    mitigate: z.lazy(() => UpdateProjectDataCacheInternalRoutesMitigate$inboundSchema),
+    src: z.string().optional(),
+});
+/** @internal */
+export const InternalRoutes2$outboundSchema = z.object({
+    has: z.array(z.union([
+        z.lazy(() => Has1$outboundSchema),
+        z.lazy(() => Has2$outboundSchema),
+    ])),
+    mitigate: z.lazy(() => UpdateProjectDataCacheInternalRoutesMitigate$outboundSchema),
+    src: z.string().optional(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var InternalRoutes2$;
+(function (InternalRoutes2$) {
+    /** @deprecated use `InternalRoutes2$inboundSchema` instead. */
+    InternalRoutes2$.inboundSchema = InternalRoutes2$inboundSchema;
+    /** @deprecated use `InternalRoutes2$outboundSchema` instead. */
+    InternalRoutes2$.outboundSchema = InternalRoutes2$outboundSchema;
+})(InternalRoutes2$ || (InternalRoutes2$ = {}));
+export function internalRoutes2ToJSON(internalRoutes2) {
+    return JSON.stringify(InternalRoutes2$outboundSchema.parse(internalRoutes2));
+}
+export function internalRoutes2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => InternalRoutes2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'InternalRoutes2' from JSON`);
+}
+/** @internal */
+export const InternalRoutes1$inboundSchema = z.object({
+    src: z.string(),
+    status: z.number(),
+});
+/** @internal */
+export const InternalRoutes1$outboundSchema = z.object({
+    src: z.string(),
+    status: z.number(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var InternalRoutes1$;
+(function (InternalRoutes1$) {
+    /** @deprecated use `InternalRoutes1$inboundSchema` instead. */
+    InternalRoutes1$.inboundSchema = InternalRoutes1$inboundSchema;
+    /** @deprecated use `InternalRoutes1$outboundSchema` instead. */
+    InternalRoutes1$.outboundSchema = InternalRoutes1$outboundSchema;
+})(InternalRoutes1$ || (InternalRoutes1$ = {}));
+export function internalRoutes1ToJSON(internalRoutes1) {
+    return JSON.stringify(InternalRoutes1$outboundSchema.parse(internalRoutes1));
+}
+export function internalRoutes1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => InternalRoutes1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'InternalRoutes1' from JSON`);
+}
+/** @internal */
+export const InternalRoutes$inboundSchema = z.union([
+    z.lazy(() => InternalRoutes1$inboundSchema),
+    z.lazy(() => InternalRoutes2$inboundSchema),
+]);
+/** @internal */
+export const InternalRoutes$outboundSchema = z.union([
+    z.lazy(() => InternalRoutes1$outboundSchema),
+    z.lazy(() => InternalRoutes2$outboundSchema),
+]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var InternalRoutes$;
+(function (InternalRoutes$) {
+    /** @deprecated use `InternalRoutes$inboundSchema` instead. */
+    InternalRoutes$.inboundSchema = InternalRoutes$inboundSchema;
+    /** @deprecated use `InternalRoutes$outboundSchema` instead. */
+    InternalRoutes$.outboundSchema = InternalRoutes$outboundSchema;
+})(InternalRoutes$ || (InternalRoutes$ = {}));
+export function internalRoutesToJSON(internalRoutes) {
+    return JSON.stringify(InternalRoutes$outboundSchema.parse(internalRoutes));
+}
+export function internalRoutesFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => InternalRoutes$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'InternalRoutes' from JSON`);
+}
+/** @internal */
+export const UpdateProjectDataCacheResponseBody$inboundSchema = z.object({
+    accountId: z.string(),
+    analytics: z.lazy(() => Analytics$inboundSchema).optional(),
+    speedInsights: z.lazy(() => SpeedInsights$inboundSchema).optional(),
+    autoExposeSystemEnvs: z.boolean().optional(),
+    autoAssignCustomDomains: z.boolean().optional(),
+    autoAssignCustomDomainsUpdatedBy: z.string().optional(),
+    buildCommand: z.nullable(z.string()).optional(),
+    commandForIgnoringBuildStep: z.nullable(z.string()).optional(),
+    connectConfigurations: z.nullable(z.array(z.lazy(() => UpdateProjectDataCacheConnectConfigurations$inboundSchema))).optional(),
+    connectConfigurationId: z.nullable(z.string()).optional(),
+    connectBuildsEnabled: z.boolean().optional(),
+    passiveConnectConfigurationId: z.nullable(z.string()).optional(),
+    createdAt: z.number().optional(),
+    customerSupportCodeVisibility: z.boolean().optional(),
+    crons: z.lazy(() => Crons$inboundSchema).optional(),
+    dataCache: z.lazy(() => UpdateProjectDataCacheDataCache$inboundSchema)
+        .optional(),
+    deploymentExpiration: z.nullable(z.lazy(() => DeploymentExpiration$inboundSchema)).optional(),
+    devCommand: z.nullable(z.string()).optional(),
+    directoryListing: z.boolean(),
+    installCommand: z.nullable(z.string()).optional(),
+    env: z.array(z.lazy(() => Env$inboundSchema)).optional(),
+    customEnvironments: z.array(z.lazy(() => CustomEnvironments$inboundSchema))
+        .optional(),
+    framework: z.nullable(UpdateProjectDataCacheFramework$inboundSchema)
+        .optional(),
+    gitForkProtection: z.boolean().optional(),
+    gitLFS: z.boolean().optional(),
+    id: z.string(),
+    ipBuckets: z.array(z.lazy(() => UpdateProjectDataCacheIpBuckets$inboundSchema)).optional(),
+    latestDeployments: z.array(z.lazy(() => LatestDeployments$inboundSchema))
+        .optional(),
+    link: z.union([
+        z.lazy(() => Link4$inboundSchema),
+        z.lazy(() => Link5$inboundSchema),
+        z.lazy(() => Link3$inboundSchema),
+        z.lazy(() => Link1$inboundSchema),
+        z.lazy(() => Link2$inboundSchema),
+    ]).optional(),
+    microfrontends: z.union([
+        z.lazy(() => UpdateProjectDataCacheMicrofrontends1$inboundSchema),
+        z.lazy(() => UpdateProjectDataCacheMicrofrontends2$inboundSchema),
+    ]).optional(),
+    name: z.string(),
+    nodeVersion: UpdateProjectDataCacheNodeVersion$inboundSchema,
+    optionsAllowlist: z.nullable(z.lazy(() => UpdateProjectDataCacheOptionsAllowlist$inboundSchema)).optional(),
+    outputDirectory: z.nullable(z.string()).optional(),
+    passwordProtection: z.nullable(z.lazy(() => UpdateProjectDataCachePasswordProtection$inboundSchema)).optional(),
+    productionDeploymentsFastLane: z.boolean().optional(),
+    publicSource: z.nullable(z.boolean()).optional(),
+    resourceConfig: z.lazy(() => UpdateProjectDataCacheResourceConfig$inboundSchema),
+    rollbackDescription: z.lazy(() => RollbackDescription$inboundSchema)
+        .optional(),
+    rollingRelease: z.nullable(z.lazy(() => RollingRelease$inboundSchema))
+        .optional(),
+    defaultResourceConfig: z.lazy(() => DefaultResourceConfig$inboundSchema),
+    rootDirectory: z.nullable(z.string()).optional(),
+    serverlessFunctionZeroConfigFailover: z.boolean().optional(),
+    skewProtectionBoundaryAt: z.number().optional(),
+    skewProtectionMaxAge: z.number().optional(),
+    skipGitConnectDuringLink: z.boolean().optional(),
+    sourceFilesOutsideRootDirectory: z.boolean().optional(),
+    enableAffectedProjectsDeployments: z.boolean().optional(),
+    ssoProtection: z.nullable(z.lazy(() => UpdateProjectDataCacheSsoProtection$inboundSchema)).optional(),
+    targets: z.record(z.nullable(z.lazy(() => Targets$inboundSchema))).optional(),
+    transferCompletedAt: z.number().optional(),
+    transferStartedAt: z.number().optional(),
+    transferToAccountId: z.string().optional(),
+    transferredFromAccountId: z.string().optional(),
+    updatedAt: z.number().optional(),
+    live: z.boolean().optional(),
+    enablePreviewFeedback: z.nullable(z.boolean()).optional(),
+    enableProductionFeedback: z.nullable(z.boolean()).optional(),
+    permissions: z.lazy(() => Permissions$inboundSchema).optional(),
+    lastRollbackTarget: z.nullable(z.lazy(() => LastRollbackTarget$inboundSchema))
+        .optional(),
+    lastAliasRequest: z.nullable(z.lazy(() => LastAliasRequest$inboundSchema))
+        .optional(),
+    protectionBypass: z.record(z.union([
+        z.lazy(() => ProtectionBypass1$inboundSchema),
+        z.lazy(() => ProtectionBypass2$inboundSchema),
+    ])).optional(),
+    hasActiveBranches: z.boolean().optional(),
+    trustedIps: z.nullable(z.union([
+        z.lazy(() => TrustedIps1$inboundSchema),
+        z.lazy(() => TrustedIps2$inboundSchema),
+    ])).optional(),
+    gitComments: z.lazy(() => GitComments$inboundSchema).optional(),
+    gitProviderOptions: z.lazy(() => GitProviderOptions$inboundSchema).optional(),
+    paused: z.boolean().optional(),
+    concurrencyBucketName: z.string().optional(),
+    webAnalytics: z.lazy(() => UpdateProjectDataCacheWebAnalytics$inboundSchema)
+        .optional(),
+    security: z.lazy(() => UpdateProjectDataCacheSecurity$inboundSchema)
+        .optional(),
+    oidcTokenConfig: z.lazy(() => UpdateProjectDataCacheOidcTokenConfig$inboundSchema).optional(),
+    tier: UpdateProjectDataCacheTier$inboundSchema.optional(),
+    features: z.lazy(() => Features$inboundSchema).optional(),
+    v0: z.boolean().optional(),
+    abuse: z.lazy(() => UpdateProjectDataCacheAbuse$inboundSchema).optional(),
+    internalRoutes: z.array(z.union([
+        z.lazy(() => InternalRoutes1$inboundSchema),
+        z.lazy(() => InternalRoutes2$inboundSchema),
+    ])).optional(),
+});
+/** @internal */
+export const UpdateProjectDataCacheResponseBody$outboundSchema = z.object({
+    accountId: z.string(),
+    analytics: z.lazy(() => Analytics$outboundSchema).optional(),
+    speedInsights: z.lazy(() => SpeedInsights$outboundSchema).optional(),
+    autoExposeSystemEnvs: z.boolean().optional(),
+    autoAssignCustomDomains: z.boolean().optional(),
+    autoAssignCustomDomainsUpdatedBy: z.string().optional(),
+    buildCommand: z.nullable(z.string()).optional(),
+    commandForIgnoringBuildStep: z.nullable(z.string()).optional(),
+    connectConfigurations: z.nullable(z.array(z.lazy(() => UpdateProjectDataCacheConnectConfigurations$outboundSchema))).optional(),
+    connectConfigurationId: z.nullable(z.string()).optional(),
+    connectBuildsEnabled: z.boolean().optional(),
+    passiveConnectConfigurationId: z.nullable(z.string()).optional(),
+    createdAt: z.number().optional(),
+    customerSupportCodeVisibility: z.boolean().optional(),
+    crons: z.lazy(() => Crons$outboundSchema).optional(),
+    dataCache: z.lazy(() => UpdateProjectDataCacheDataCache$outboundSchema)
+        .optional(),
+    deploymentExpiration: z.nullable(z.lazy(() => DeploymentExpiration$outboundSchema)).optional(),
+    devCommand: z.nullable(z.string()).optional(),
+    directoryListing: z.boolean(),
+    installCommand: z.nullable(z.string()).optional(),
+    env: z.array(z.lazy(() => Env$outboundSchema)).optional(),
+    customEnvironments: z.array(z.lazy(() => CustomEnvironments$outboundSchema))
+        .optional(),
+    framework: z.nullable(UpdateProjectDataCacheFramework$outboundSchema)
+        .optional(),
+    gitForkProtection: z.boolean().optional(),
+    gitLFS: z.boolean().optional(),
+    id: z.string(),
+    ipBuckets: z.array(z.lazy(() => UpdateProjectDataCacheIpBuckets$outboundSchema)).optional(),
+    latestDeployments: z.array(z.lazy(() => LatestDeployments$outboundSchema))
+        .optional(),
+    link: z.union([
+        z.lazy(() => Link4$outboundSchema),
+        z.lazy(() => Link5$outboundSchema),
+        z.lazy(() => Link3$outboundSchema),
+        z.lazy(() => Link1$outboundSchema),
+        z.lazy(() => Link2$outboundSchema),
+    ]).optional(),
+    microfrontends: z.union([
+        z.lazy(() => UpdateProjectDataCacheMicrofrontends1$outboundSchema),
+        z.lazy(() => UpdateProjectDataCacheMicrofrontends2$outboundSchema),
+    ]).optional(),
+    name: z.string(),
+    nodeVersion: UpdateProjectDataCacheNodeVersion$outboundSchema,
+    optionsAllowlist: z.nullable(z.lazy(() => UpdateProjectDataCacheOptionsAllowlist$outboundSchema)).optional(),
+    outputDirectory: z.nullable(z.string()).optional(),
+    passwordProtection: z.nullable(z.lazy(() => UpdateProjectDataCachePasswordProtection$outboundSchema)).optional(),
+    productionDeploymentsFastLane: z.boolean().optional(),
+    publicSource: z.nullable(z.boolean()).optional(),
     resourceConfig: z.lazy(() => UpdateProjectDataCacheResourceConfig$outboundSchema),
     rollbackDescription: z.lazy(() => RollbackDescription$outboundSchema)
         .optional(),
@@ -5022,6 +6401,11 @@ export const UpdateProjectDataCacheResponseBody$outboundSchema = z.object({
     tier: UpdateProjectDataCacheTier$outboundSchema.optional(),
     features: z.lazy(() => Features$outboundSchema).optional(),
     v0: z.boolean().optional(),
+    abuse: z.lazy(() => UpdateProjectDataCacheAbuse$outboundSchema).optional(),
+    internalRoutes: z.array(z.union([
+        z.lazy(() => InternalRoutes1$outboundSchema),
+        z.lazy(() => InternalRoutes2$outboundSchema),
+    ])).optional(),
 });
 /**
  * @internal