@vercel/sdk 1.10.8 → 1.11.0

package/esm/models/updateprojectdatacacheop.d.ts

@@ -606,7 +606,7 @@ export type LatestDeployments = {
     withCache?: boolean | undefined;
 };
 export declare const UpdateProjectDataCacheLinkProjectsResponse200Type: {
-    readonly GithubCustomHost: "github-custom-host";
+    readonly Bitbucket: "bitbucket";
 };
 export type UpdateProjectDataCacheLinkProjectsResponse200Type = ClosedEnum<typeof UpdateProjectDataCacheLinkProjectsResponse200Type>;
 export type UpdateProjectDataCacheLinkProjectsResponseDeployHooks = {
@@ -617,15 +617,12 @@ export type UpdateProjectDataCacheLinkProjectsResponseDeployHooks = {
     url: string;
 };
 export type Link5 = {
-    org: string;
-    /**
-     * A new field, should be included in all new project links, is being added just in time when a deployment is created. This is needed for Protected Git scopes.
-     */
-    repoOwnerId?: number | undefined;
-    repo?: string | undefined;
-    repoId?: number | undefined;
+    name: string;
+    slug: string;
+    owner: string;
     type: UpdateProjectDataCacheLinkProjectsResponse200Type;
-    host: string;
+    uuid: string;
+    workspaceUuid: string;
     createdAt?: number | undefined;
     deployHooks: Array<UpdateProjectDataCacheLinkProjectsResponseDeployHooks>;
     gitCredentialId: string;
@@ -634,7 +631,7 @@ export type Link5 = {
     productionBranch: string;
 };
 export declare const UpdateProjectDataCacheLinkProjectsResponseType: {
-    readonly Bitbucket: "bitbucket";
+    readonly Gitlab: "gitlab";
 };
 export type UpdateProjectDataCacheLinkProjectsResponseType = ClosedEnum<typeof UpdateProjectDataCacheLinkProjectsResponseType>;
 export type UpdateProjectDataCacheLinkProjectsDeployHooks = {
@@ -645,12 +642,16 @@ export type UpdateProjectDataCacheLinkProjectsDeployHooks = {
     url: string;
 };
 export type Link4 = {
-    name: string;
-    slug: string;
-    owner: string;
+    projectId: string;
+    projectName: string;
+    projectNameWithNamespace: string;
+    projectNamespace: string;
+    /**
+     * A new field, should be included in all new project links, is being added just in time when a deployment is created. This is needed for Protected Git scopes. This is the id of the top level group that a namespace belongs to. Gitlab supports group nesting (up to 20 levels).
+     */
+    projectOwnerId?: number | undefined;
+    projectUrl: string;
     type: UpdateProjectDataCacheLinkProjectsResponseType;
-    uuid: string;
-    workspaceUuid: string;
     createdAt?: number | undefined;
     deployHooks: Array<UpdateProjectDataCacheLinkProjectsDeployHooks>;
     gitCredentialId: string;
@@ -659,7 +660,7 @@ export type Link4 = {
     productionBranch: string;
 };
 export declare const UpdateProjectDataCacheLinkProjectsType: {
-    readonly Gitlab: "gitlab";
+    readonly GithubCustomHost: "github-custom-host";
 };
 export type UpdateProjectDataCacheLinkProjectsType = ClosedEnum<typeof UpdateProjectDataCacheLinkProjectsType>;
 export type UpdateProjectDataCacheLinkDeployHooks = {
@@ -670,16 +671,15 @@ export type UpdateProjectDataCacheLinkDeployHooks = {
     url: string;
 };
 export type Link3 = {
-    projectId: string;
-    projectName: string;
-    projectNameWithNamespace: string;
-    projectNamespace: string;
+    org: string;
     /**
-     * A new field, should be included in all new project links, is being added just in time when a deployment is created. This is needed for Protected Git scopes. This is the id of the top level group that a namespace belongs to. Gitlab supports group nesting (up to 20 levels).
+     * A new field, should be included in all new project links, is being added just in time when a deployment is created. This is needed for Protected Git scopes.
      */
-    projectOwnerId?: number | undefined;
-    projectUrl: string;
+    repoOwnerId?: number | undefined;
+    repo?: string | undefined;
+    repoId?: number | undefined;
     type: UpdateProjectDataCacheLinkProjectsType;
+    host: string;
     createdAt?: number | undefined;
     deployHooks: Array<UpdateProjectDataCacheLinkDeployHooks>;
     gitCredentialId: string;
@@ -741,7 +741,7 @@ export type Link1 = {
     sourceless?: boolean | undefined;
     productionBranch: string;
 };
-export type Link = Link3 | Link4 | Link5 | Link1 | Link2;
+export type Link = Link4 | Link5 | Link3 | Link1 | Link2;
 export type UpdateProjectDataCacheMicrofrontends2 = {
     updatedAt: number;
     groupIds: Array<any>;
@@ -1117,6 +1117,7 @@ export type Permissions = {
     notificationCustomerBudget?: Array<ACLAction> | undefined;
     notificationStatementOfReasons?: Array<ACLAction> | undefined;
     observabilityConfiguration?: Array<ACLAction> | undefined;
+    alerts?: Array<ACLAction> | undefined;
     observabilityNotebook?: Array<ACLAction> | undefined;
     observabilityFunnel?: Array<ACLAction> | undefined;
     openTelemetryEndpoint?: Array<ACLAction> | undefined;
@@ -1372,15 +1373,15 @@ export type BotFilter = {
     active: boolean;
     action?: UpdateProjectDataCacheProjectsResponseAction | undefined;
 };
-export declare const UpdateProjectDataCacheAction: {
+export declare const UpdateProjectDataCacheProjectsResponse200Action: {
     readonly Log: "log";
     readonly Challenge: "challenge";
     readonly Deny: "deny";
 };
-export type UpdateProjectDataCacheAction = ClosedEnum<typeof UpdateProjectDataCacheAction>;
+export type UpdateProjectDataCacheProjectsResponse200Action = ClosedEnum<typeof UpdateProjectDataCacheProjectsResponse200Action>;
 export type UpdateProjectDataCacheAiBots = {
     active: boolean;
-    action?: UpdateProjectDataCacheAction | undefined;
+    action?: UpdateProjectDataCacheProjectsResponse200Action | undefined;
 };
 export declare const UpdateProjectDataCacheProjectsAction: {
     readonly Log: "log";
@@ -1441,6 +1442,224 @@ export type UpdateProjectDataCacheTier = ClosedEnum<typeof UpdateProjectDataCach
 export type Features = {
     webAnalytics?: boolean | undefined;
 };
+export type UpdateProjectDataCacheHistory = {
+    scanner: string;
+    reason: string;
+    by: string;
+    byId: string;
+    at: number;
+};
+export declare const UpdateProjectDataCacheAction: {
+    readonly Blocked: "blocked";
+};
+export type UpdateProjectDataCacheAction = ClosedEnum<typeof UpdateProjectDataCacheAction>;
+export type Block = {
+    action: UpdateProjectDataCacheAction;
+    reason: string;
+    statusCode: number;
+    createdAt: number;
+    caseId?: string | undefined;
+    actor?: string | undefined;
+    comment?: string | undefined;
+    isCascading?: boolean | undefined;
+};
+export declare const UpdateProjectDataCacheBlockHistoryProjectsResponseAction: {
+    readonly RouteUnblocked: "route-unblocked";
+};
+export type UpdateProjectDataCacheBlockHistoryProjectsResponseAction = ClosedEnum<typeof UpdateProjectDataCacheBlockHistoryProjectsResponseAction>;
+export declare const UpdateProjectDataCacheHasProjectsResponseType: {
+    readonly Host: "host";
+};
+export type UpdateProjectDataCacheHasProjectsResponseType = ClosedEnum<typeof UpdateProjectDataCacheHasProjectsResponseType>;
+export type UpdateProjectDataCacheHasProjectsValue = {
+    eq: string;
+};
+export type UpdateProjectDataCacheHas2 = {
+    type: UpdateProjectDataCacheHasProjectsResponseType;
+    value: UpdateProjectDataCacheHasProjectsValue;
+};
+export declare const UpdateProjectDataCacheHasProjectsType: {
+    readonly Header: "header";
+};
+export type UpdateProjectDataCacheHasProjectsType = ClosedEnum<typeof UpdateProjectDataCacheHasProjectsType>;
+export declare const UpdateProjectDataCacheHasProjectsKey: {
+    readonly XVercelIpCountry: "x-vercel-ip-country";
+};
+export type UpdateProjectDataCacheHasProjectsKey = ClosedEnum<typeof UpdateProjectDataCacheHasProjectsKey>;
+export type UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue = {
+    eq: string;
+};
+export type UpdateProjectDataCacheHas1 = {
+    type: UpdateProjectDataCacheHasProjectsType;
+    key: UpdateProjectDataCacheHasProjectsKey;
+    value: UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue;
+};
+export type RouteHas = UpdateProjectDataCacheHas1 | UpdateProjectDataCacheHas2;
+export declare const UpdateProjectDataCacheRouteAction: {
+    readonly BlockLegalCwc: "block_legal_cwc";
+};
+export type UpdateProjectDataCacheRouteAction = ClosedEnum<typeof UpdateProjectDataCacheRouteAction>;
+export type RouteMitigate = {
+    action: UpdateProjectDataCacheRouteAction;
+};
+export type UpdateProjectDataCacheRoute2 = {
+    has: Array<UpdateProjectDataCacheHas1 | UpdateProjectDataCacheHas2>;
+    mitigate: RouteMitigate;
+    src?: string | undefined;
+};
+export type UpdateProjectDataCacheRoute1 = {
+    src: string;
+    status: number;
+};
+export type BlockHistoryRoute = UpdateProjectDataCacheRoute1 | UpdateProjectDataCacheRoute2;
+export type BlockHistory4 = {
+    action: UpdateProjectDataCacheBlockHistoryProjectsResponseAction;
+    route: UpdateProjectDataCacheRoute1 | UpdateProjectDataCacheRoute2;
+    statusCode?: number | undefined;
+    createdAt: number;
+    caseId?: string | undefined;
+    actor?: string | undefined;
+    comment?: string | undefined;
+    isCascading?: boolean | undefined;
+};
+export declare const UpdateProjectDataCacheBlockHistoryProjectsAction: {
+    readonly RouteBlocked: "route-blocked";
+};
+export type UpdateProjectDataCacheBlockHistoryProjectsAction = ClosedEnum<typeof UpdateProjectDataCacheBlockHistoryProjectsAction>;
+export declare const UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType: {
+    readonly Host: "host";
+};
+export type UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType = ClosedEnum<typeof UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType>;
+export type UpdateProjectDataCacheHasProjectsResponse200Value = {
+    eq: string;
+};
+export type UpdateProjectDataCacheHasProjects2 = {
+    type: UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType;
+    value: UpdateProjectDataCacheHasProjectsResponse200Value;
+};
+export declare const UpdateProjectDataCacheHasProjectsResponse200Type: {
+    readonly Header: "header";
+};
+export type UpdateProjectDataCacheHasProjectsResponse200Type = ClosedEnum<typeof UpdateProjectDataCacheHasProjectsResponse200Type>;
+export declare const UpdateProjectDataCacheHasKey: {
+    readonly XVercelIpCountry: "x-vercel-ip-country";
+};
+export type UpdateProjectDataCacheHasKey = ClosedEnum<typeof UpdateProjectDataCacheHasKey>;
+export type UpdateProjectDataCacheHasProjectsResponseValue = {
+    eq: string;
+};
+export type UpdateProjectDataCacheHasProjects1 = {
+    type: UpdateProjectDataCacheHasProjectsResponse200Type;
+    key: UpdateProjectDataCacheHasKey;
+    value: UpdateProjectDataCacheHasProjectsResponseValue;
+};
+export type UpdateProjectDataCacheRouteHas = UpdateProjectDataCacheHasProjects1 | UpdateProjectDataCacheHasProjects2;
+export declare const RouteAction: {
+    readonly BlockLegalCwc: "block_legal_cwc";
+};
+export type RouteAction = ClosedEnum<typeof RouteAction>;
+export type UpdateProjectDataCacheRouteMitigate = {
+    action: RouteAction;
+};
+export type Route2 = {
+    has: Array<UpdateProjectDataCacheHasProjects1 | UpdateProjectDataCacheHasProjects2>;
+    mitigate: UpdateProjectDataCacheRouteMitigate;
+    src?: string | undefined;
+};
+export type Route1 = {
+    src: string;
+    status: number;
+};
+export type Route = Route1 | Route2;
+export type BlockHistory3 = {
+    action: UpdateProjectDataCacheBlockHistoryProjectsAction;
+    route: Route1 | Route2;
+    reason: string;
+    createdAt: number;
+    caseId?: string | undefined;
+    actor?: string | undefined;
+    comment?: string | undefined;
+    isCascading?: boolean | undefined;
+};
+export declare const UpdateProjectDataCacheBlockHistoryAction: {
+    readonly Unblocked: "unblocked";
+};
+export type UpdateProjectDataCacheBlockHistoryAction = ClosedEnum<typeof UpdateProjectDataCacheBlockHistoryAction>;
+export type BlockHistory2 = {
+    action: UpdateProjectDataCacheBlockHistoryAction;
+    createdAt: number;
+    caseId?: string | undefined;
+    actor?: string | undefined;
+    comment?: string | undefined;
+    isCascading?: boolean | undefined;
+};
+export declare const BlockHistoryAction: {
+    readonly Blocked: "blocked";
+};
+export type BlockHistoryAction = ClosedEnum<typeof BlockHistoryAction>;
+export type BlockHistory1 = {
+    action: BlockHistoryAction;
+    reason: string;
+    statusCode: number;
+    createdAt: number;
+    caseId?: string | undefined;
+    actor?: string | undefined;
+    comment?: string | undefined;
+    isCascading?: boolean | undefined;
+};
+export type UpdateProjectDataCacheBlockHistory = BlockHistory1 | BlockHistory3 | BlockHistory4 | BlockHistory2;
+export type UpdateProjectDataCacheAbuse = {
+    scanner?: string | undefined;
+    history: Array<UpdateProjectDataCacheHistory>;
+    updatedAt: number;
+    block?: Block | undefined;
+    blockHistory?: Array<BlockHistory1 | BlockHistory3 | BlockHistory4 | BlockHistory2> | undefined;
+};
+export declare const UpdateProjectDataCacheHasType: {
+    readonly Host: "host";
+};
+export type UpdateProjectDataCacheHasType = ClosedEnum<typeof UpdateProjectDataCacheHasType>;
+export type HasValue = {
+    eq: string;
+};
+export type Has2 = {
+    type: UpdateProjectDataCacheHasType;
+    value: HasValue;
+};
+export declare const HasType: {
+    readonly Header: "header";
+};
+export type HasType = ClosedEnum<typeof HasType>;
+export declare const Key: {
+    readonly XVercelIpCountry: "x-vercel-ip-country";
+};
+export type Key = ClosedEnum<typeof Key>;
+export type UpdateProjectDataCacheHasValue = {
+    eq: string;
+};
+export type Has1 = {
+    type: HasType;
+    key: Key;
+    value: UpdateProjectDataCacheHasValue;
+};
+export type Has = Has1 | Has2;
+export declare const InternalRoutesAction: {
+    readonly BlockLegalCwc: "block_legal_cwc";
+};
+export type InternalRoutesAction = ClosedEnum<typeof InternalRoutesAction>;
+export type UpdateProjectDataCacheInternalRoutesMitigate = {
+    action: InternalRoutesAction;
+};
+export type InternalRoutes2 = {
+    has: Array<Has1 | Has2>;
+    mitigate: UpdateProjectDataCacheInternalRoutesMitigate;
+    src?: string | undefined;
+};
+export type InternalRoutes1 = {
+    src: string;
+    status: number;
+};
+export type InternalRoutes = InternalRoutes1 | InternalRoutes2;
 export type UpdateProjectDataCacheResponseBody = {
     accountId: string;
     analytics?: Analytics | undefined;
@@ -1473,7 +1692,7 @@ export type UpdateProjectDataCacheResponseBody = {
     id: string;
     ipBuckets?: Array<UpdateProjectDataCacheIpBuckets> | undefined;
     latestDeployments?: Array<LatestDeployments> | undefined;
-    link?: Link3 | Link4 | Link5 | Link1 | Link2 | undefined;
+    link?: Link4 | Link5 | Link3 | Link1 | Link2 | undefined;
     microfrontends?: UpdateProjectDataCacheMicrofrontends1 | UpdateProjectDataCacheMicrofrontends2 | undefined;
     name: string;
     nodeVersion: UpdateProjectDataCacheNodeVersion;
@@ -1529,6 +1748,8 @@ export type UpdateProjectDataCacheResponseBody = {
     tier?: UpdateProjectDataCacheTier | undefined;
     features?: Features | undefined;
     v0?: boolean | undefined;
+    abuse?: UpdateProjectDataCacheAbuse | undefined;
+    internalRoutes?: Array<InternalRoutes1 | InternalRoutes2> | undefined;
 };
 /** @internal */
 export declare const UpdateProjectDataCacheRequestBody$inboundSchema: z.ZodType<UpdateProjectDataCacheRequestBody, z.ZodTypeDef, unknown>;
@@ -3301,11 +3522,11 @@ export declare const UpdateProjectDataCacheLinkProjectsResponse200Type$outboundS
 export declare namespace UpdateProjectDataCacheLinkProjectsResponse200Type$ {
     /** @deprecated use `UpdateProjectDataCacheLinkProjectsResponse200Type$inboundSchema` instead. */
     const inboundSchema: z.ZodNativeEnum<{
-        readonly GithubCustomHost: "github-custom-host";
+        readonly Bitbucket: "bitbucket";
     }>;
     /** @deprecated use `UpdateProjectDataCacheLinkProjectsResponse200Type$outboundSchema` instead. */
     const outboundSchema: z.ZodNativeEnum<{
-        readonly GithubCustomHost: "github-custom-host";
+        readonly Bitbucket: "bitbucket";
     }>;
 }
 /** @internal */
@@ -3338,12 +3559,12 @@ export declare function updateProjectDataCacheLinkProjectsResponseDeployHooksFro
 export declare const Link5$inboundSchema: z.ZodType<Link5, z.ZodTypeDef, unknown>;
 /** @internal */
 export type Link5$Outbound = {
-    org: string;
-    repoOwnerId?: number | undefined;
-    repo?: string | undefined;
-    repoId?: number | undefined;
+    name: string;
+    slug: string;
+    owner: string;
     type: string;
-    host: string;
+    uuid: string;
+    workspaceUuid: string;
     createdAt?: number | undefined;
     deployHooks: Array<UpdateProjectDataCacheLinkProjectsResponseDeployHooks$Outbound>;
     gitCredentialId: string;
@@ -3378,11 +3599,11 @@ export declare const UpdateProjectDataCacheLinkProjectsResponseType$outboundSche
 export declare namespace UpdateProjectDataCacheLinkProjectsResponseType$ {
     /** @deprecated use `UpdateProjectDataCacheLinkProjectsResponseType$inboundSchema` instead. */
     const inboundSchema: z.ZodNativeEnum<{
-        readonly Bitbucket: "bitbucket";
+        readonly Gitlab: "gitlab";
     }>;
     /** @deprecated use `UpdateProjectDataCacheLinkProjectsResponseType$outboundSchema` instead. */
     const outboundSchema: z.ZodNativeEnum<{
-        readonly Bitbucket: "bitbucket";
+        readonly Gitlab: "gitlab";
     }>;
 }
 /** @internal */
@@ -3415,12 +3636,13 @@ export declare function updateProjectDataCacheLinkProjectsDeployHooksFromJSON(js
 export declare const Link4$inboundSchema: z.ZodType<Link4, z.ZodTypeDef, unknown>;
 /** @internal */
 export type Link4$Outbound = {
-    name: string;
-    slug: string;
-    owner: string;
+    projectId: string;
+    projectName: string;
+    projectNameWithNamespace: string;
+    projectNamespace: string;
+    projectOwnerId?: number | undefined;
+    projectUrl: string;
     type: string;
-    uuid: string;
-    workspaceUuid: string;
     createdAt?: number | undefined;
     deployHooks: Array<UpdateProjectDataCacheLinkProjectsDeployHooks$Outbound>;
     gitCredentialId: string;
@@ -3455,11 +3677,11 @@ export declare const UpdateProjectDataCacheLinkProjectsType$outboundSchema: z.Zo
 export declare namespace UpdateProjectDataCacheLinkProjectsType$ {
     /** @deprecated use `UpdateProjectDataCacheLinkProjectsType$inboundSchema` instead. */
     const inboundSchema: z.ZodNativeEnum<{
-        readonly Gitlab: "gitlab";
+        readonly GithubCustomHost: "github-custom-host";
     }>;
     /** @deprecated use `UpdateProjectDataCacheLinkProjectsType$outboundSchema` instead. */
     const outboundSchema: z.ZodNativeEnum<{
-        readonly Gitlab: "gitlab";
+        readonly GithubCustomHost: "github-custom-host";
     }>;
 }
 /** @internal */
@@ -3492,13 +3714,12 @@ export declare function updateProjectDataCacheLinkDeployHooksFromJSON(jsonString
 export declare const Link3$inboundSchema: z.ZodType<Link3, z.ZodTypeDef, unknown>;
 /** @internal */
 export type Link3$Outbound = {
-    projectId: string;
-    projectName: string;
-    projectNameWithNamespace: string;
-    projectNamespace: string;
-    projectOwnerId?: number | undefined;
-    projectUrl: string;
+    org: string;
+    repoOwnerId?: number | undefined;
+    repo?: string | undefined;
+    repoId?: number | undefined;
     type: string;
+    host: string;
     createdAt?: number | undefined;
     deployHooks: Array<UpdateProjectDataCacheLinkDeployHooks$Outbound>;
     gitCredentialId: string;
@@ -3677,7 +3898,7 @@ export declare function link1FromJSON(jsonString: string): SafeParseResult<Link1
 /** @internal */
 export declare const Link$inboundSchema: z.ZodType<Link, z.ZodTypeDef, unknown>;
 /** @internal */
-export type Link$Outbound = Link3$Outbound | Link4$Outbound | Link5$Outbound | Link1$Outbound | Link2$Outbound;
+export type Link$Outbound = Link4$Outbound | Link5$Outbound | Link3$Outbound | Link1$Outbound | Link2$Outbound;
 /** @internal */
 export declare const Link$outboundSchema: z.ZodType<Link$Outbound, z.ZodTypeDef, Link>;
 /**
@@ -4575,6 +4796,7 @@ export type Permissions$Outbound = {
     notificationCustomerBudget?: Array<string> | undefined;
     notificationStatementOfReasons?: Array<string> | undefined;
     observabilityConfiguration?: Array<string> | undefined;
+    alerts?: Array<string> | undefined;
     observabilityNotebook?: Array<string> | undefined;
     observabilityFunnel?: Array<string> | undefined;
     openTelemetryEndpoint?: Array<string> | undefined;
@@ -5216,21 +5438,21 @@ export declare namespace BotFilter$ {
 export declare function botFilterToJSON(botFilter: BotFilter): string;
 export declare function botFilterFromJSON(jsonString: string): SafeParseResult<BotFilter, SDKValidationError>;
 /** @internal */
-export declare const UpdateProjectDataCacheAction$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheAction>;
+export declare const UpdateProjectDataCacheProjectsResponse200Action$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsResponse200Action>;
 /** @internal */
-export declare const UpdateProjectDataCacheAction$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheAction>;
+export declare const UpdateProjectDataCacheProjectsResponse200Action$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsResponse200Action>;
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export declare namespace UpdateProjectDataCacheAction$ {
-    /** @deprecated use `UpdateProjectDataCacheAction$inboundSchema` instead. */
+export declare namespace UpdateProjectDataCacheProjectsResponse200Action$ {
+    /** @deprecated use `UpdateProjectDataCacheProjectsResponse200Action$inboundSchema` instead. */
     const inboundSchema: z.ZodNativeEnum<{
         readonly Log: "log";
         readonly Challenge: "challenge";
         readonly Deny: "deny";
     }>;
-    /** @deprecated use `UpdateProjectDataCacheAction$outboundSchema` instead. */
+    /** @deprecated use `UpdateProjectDataCacheProjectsResponse200Action$outboundSchema` instead. */
     const outboundSchema: z.ZodNativeEnum<{
         readonly Log: "log";
         readonly Challenge: "challenge";
@@ -5450,6 +5672,1127 @@ export declare namespace Features$ {
 export declare function featuresToJSON(features: Features): string;
 export declare function featuresFromJSON(jsonString: string): SafeParseResult<Features, SDKValidationError>;
 /** @internal */
+export declare const UpdateProjectDataCacheHistory$inboundSchema: z.ZodType<UpdateProjectDataCacheHistory, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheHistory$Outbound = {
+    scanner: string;
+    reason: string;
+    by: string;
+    byId: string;
+    at: number;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheHistory$outboundSchema: z.ZodType<UpdateProjectDataCacheHistory$Outbound, z.ZodTypeDef, UpdateProjectDataCacheHistory>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheHistory$ {
+    /** @deprecated use `UpdateProjectDataCacheHistory$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheHistory, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheHistory$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheHistory$Outbound, z.ZodTypeDef, UpdateProjectDataCacheHistory>;
+    /** @deprecated use `UpdateProjectDataCacheHistory$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheHistory$Outbound;
+}
+export declare function updateProjectDataCacheHistoryToJSON(updateProjectDataCacheHistory: UpdateProjectDataCacheHistory): string;
+export declare function updateProjectDataCacheHistoryFromJSON(jsonString: string): SafeParseResult<UpdateProjectDataCacheHistory, SDKValidationError>;
+/** @internal */
+export declare const UpdateProjectDataCacheAction$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheAction>;
+/** @internal */
+export declare const UpdateProjectDataCacheAction$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheAction>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheAction$ {
+    /** @deprecated use `UpdateProjectDataCacheAction$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Blocked: "blocked";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheAction$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Blocked: "blocked";
+    }>;
+}
+/** @internal */
+export declare const Block$inboundSchema: z.ZodType<Block, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Block$Outbound = {
+    action: string;
+    reason: string;
+    statusCode: number;
+    createdAt: number;
+    caseId?: string | undefined;
+    actor?: string | undefined;
+    comment?: string | undefined;
+    isCascading?: boolean | undefined;
+};
+/** @internal */
+export declare const Block$outboundSchema: z.ZodType<Block$Outbound, z.ZodTypeDef, Block>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Block$ {
+    /** @deprecated use `Block$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Block, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Block$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Block$Outbound, z.ZodTypeDef, Block>;
+    /** @deprecated use `Block$Outbound` instead. */
+    type Outbound = Block$Outbound;
+}
+export declare function blockToJSON(block: Block): string;
+export declare function blockFromJSON(jsonString: string): SafeParseResult<Block, SDKValidationError>;
+/** @internal */
+export declare const UpdateProjectDataCacheBlockHistoryProjectsResponseAction$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheBlockHistoryProjectsResponseAction>;
+/** @internal */
+export declare const UpdateProjectDataCacheBlockHistoryProjectsResponseAction$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheBlockHistoryProjectsResponseAction>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheBlockHistoryProjectsResponseAction$ {
+    /** @deprecated use `UpdateProjectDataCacheBlockHistoryProjectsResponseAction$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly RouteUnblocked: "route-unblocked";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheBlockHistoryProjectsResponseAction$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly RouteUnblocked: "route-unblocked";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheHasProjectsResponseType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheHasProjectsResponseType>;
+/** @internal */
+export declare const UpdateProjectDataCacheHasProjectsResponseType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheHasProjectsResponseType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheHasProjectsResponseType$ {
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponseType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Host: "host";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponseType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Host: "host";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheHasProjectsValue$inboundSchema: z.ZodType<UpdateProjectDataCacheHasProjectsValue, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheHasProjectsValue$Outbound = {
+    eq: string;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheHasProjectsValue$outboundSchema: z.ZodType<UpdateProjectDataCacheHasProjectsValue$Outbound, z.ZodTypeDef, UpdateProjectDataCacheHasProjectsValue>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheHasProjectsValue$ {
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsValue$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheHasProjectsValue, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsValue$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheHasProjectsValue$Outbound, z.ZodTypeDef, UpdateProjectDataCacheHasProjectsValue>;
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsValue$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheHasProjectsValue$Outbound;
+}
+export declare function updateProjectDataCacheHasProjectsValueToJSON(updateProjectDataCacheHasProjectsValue: UpdateProjectDataCacheHasProjectsValue): string;
+export declare function updateProjectDataCacheHasProjectsValueFromJSON(jsonString: string): SafeParseResult<UpdateProjectDataCacheHasProjectsValue, SDKValidationError>;
+/** @internal */
+export declare const UpdateProjectDataCacheHas2$inboundSchema: z.ZodType<UpdateProjectDataCacheHas2, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheHas2$Outbound = {
+    type: string;
+    value: UpdateProjectDataCacheHasProjectsValue$Outbound;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheHas2$outboundSchema: z.ZodType<UpdateProjectDataCacheHas2$Outbound, z.ZodTypeDef, UpdateProjectDataCacheHas2>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheHas2$ {
+    /** @deprecated use `UpdateProjectDataCacheHas2$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheHas2, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheHas2$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheHas2$Outbound, z.ZodTypeDef, UpdateProjectDataCacheHas2>;
+    /** @deprecated use `UpdateProjectDataCacheHas2$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheHas2$Outbound;
+}
+export declare function updateProjectDataCacheHas2ToJSON(updateProjectDataCacheHas2: UpdateProjectDataCacheHas2): string;
+export declare function updateProjectDataCacheHas2FromJSON(jsonString: string): SafeParseResult<UpdateProjectDataCacheHas2, SDKValidationError>;
+/** @internal */
+export declare const UpdateProjectDataCacheHasProjectsType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheHasProjectsType>;
+/** @internal */
+export declare const UpdateProjectDataCacheHasProjectsType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheHasProjectsType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheHasProjectsType$ {
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Header: "header";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Header: "header";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheHasProjectsKey$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheHasProjectsKey>;
+/** @internal */
+export declare const UpdateProjectDataCacheHasProjectsKey$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheHasProjectsKey>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheHasProjectsKey$ {
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsKey$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly XVercelIpCountry: "x-vercel-ip-country";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsKey$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly XVercelIpCountry: "x-vercel-ip-country";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$inboundSchema: z.ZodType<UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$Outbound = {
+    eq: string;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$outboundSchema: z.ZodType<UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$Outbound, z.ZodTypeDef, UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$ {
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$Outbound, z.ZodTypeDef, UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue>;
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$Outbound;
+}
+export declare function updateProjectDataCacheHasProjectsResponse200ApplicationJSONValueToJSON(updateProjectDataCacheHasProjectsResponse200ApplicationJSONValue: UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue): string;
+export declare function updateProjectDataCacheHasProjectsResponse200ApplicationJSONValueFromJSON(jsonString: string): SafeParseResult<UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue, SDKValidationError>;
+/** @internal */
+export declare const UpdateProjectDataCacheHas1$inboundSchema: z.ZodType<UpdateProjectDataCacheHas1, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheHas1$Outbound = {
+    type: string;
+    key: string;
+    value: UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONValue$Outbound;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheHas1$outboundSchema: z.ZodType<UpdateProjectDataCacheHas1$Outbound, z.ZodTypeDef, UpdateProjectDataCacheHas1>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheHas1$ {
+    /** @deprecated use `UpdateProjectDataCacheHas1$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheHas1, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheHas1$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheHas1$Outbound, z.ZodTypeDef, UpdateProjectDataCacheHas1>;
+    /** @deprecated use `UpdateProjectDataCacheHas1$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheHas1$Outbound;
+}
+export declare function updateProjectDataCacheHas1ToJSON(updateProjectDataCacheHas1: UpdateProjectDataCacheHas1): string;
+export declare function updateProjectDataCacheHas1FromJSON(jsonString: string): SafeParseResult<UpdateProjectDataCacheHas1, SDKValidationError>;
+/** @internal */
+export declare const RouteHas$inboundSchema: z.ZodType<RouteHas, z.ZodTypeDef, unknown>;
+/** @internal */
+export type RouteHas$Outbound = UpdateProjectDataCacheHas1$Outbound | UpdateProjectDataCacheHas2$Outbound;
+/** @internal */
+export declare const RouteHas$outboundSchema: z.ZodType<RouteHas$Outbound, z.ZodTypeDef, RouteHas>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace RouteHas$ {
+    /** @deprecated use `RouteHas$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<RouteHas, z.ZodTypeDef, unknown>;
+    /** @deprecated use `RouteHas$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<RouteHas$Outbound, z.ZodTypeDef, RouteHas>;
+    /** @deprecated use `RouteHas$Outbound` instead. */
+    type Outbound = RouteHas$Outbound;
+}
+export declare function routeHasToJSON(routeHas: RouteHas): string;
+export declare function routeHasFromJSON(jsonString: string): SafeParseResult<RouteHas, SDKValidationError>;
+/** @internal */
+export declare const UpdateProjectDataCacheRouteAction$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheRouteAction>;
+/** @internal */
+export declare const UpdateProjectDataCacheRouteAction$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheRouteAction>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheRouteAction$ {
+    /** @deprecated use `UpdateProjectDataCacheRouteAction$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly BlockLegalCwc: "block_legal_cwc";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheRouteAction$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly BlockLegalCwc: "block_legal_cwc";
+    }>;
+}
+/** @internal */
+export declare const RouteMitigate$inboundSchema: z.ZodType<RouteMitigate, z.ZodTypeDef, unknown>;
+/** @internal */
+export type RouteMitigate$Outbound = {
+    action: string;
+};
+/** @internal */
+export declare const RouteMitigate$outboundSchema: z.ZodType<RouteMitigate$Outbound, z.ZodTypeDef, RouteMitigate>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace RouteMitigate$ {
+    /** @deprecated use `RouteMitigate$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<RouteMitigate, z.ZodTypeDef, unknown>;
+    /** @deprecated use `RouteMitigate$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<RouteMitigate$Outbound, z.ZodTypeDef, RouteMitigate>;
+    /** @deprecated use `RouteMitigate$Outbound` instead. */
+    type Outbound = RouteMitigate$Outbound;
+}
+export declare function routeMitigateToJSON(routeMitigate: RouteMitigate): string;
+export declare function routeMitigateFromJSON(jsonString: string): SafeParseResult<RouteMitigate, SDKValidationError>;
+/** @internal */
+export declare const UpdateProjectDataCacheRoute2$inboundSchema: z.ZodType<UpdateProjectDataCacheRoute2, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheRoute2$Outbound = {
+    has: Array<UpdateProjectDataCacheHas1$Outbound | UpdateProjectDataCacheHas2$Outbound>;
+    mitigate: RouteMitigate$Outbound;
+    src?: string | undefined;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheRoute2$outboundSchema: z.ZodType<UpdateProjectDataCacheRoute2$Outbound, z.ZodTypeDef, UpdateProjectDataCacheRoute2>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheRoute2$ {
+    /** @deprecated use `UpdateProjectDataCacheRoute2$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheRoute2, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheRoute2$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheRoute2$Outbound, z.ZodTypeDef, UpdateProjectDataCacheRoute2>;
+    /** @deprecated use `UpdateProjectDataCacheRoute2$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheRoute2$Outbound;
+}
+export declare function updateProjectDataCacheRoute2ToJSON(updateProjectDataCacheRoute2: UpdateProjectDataCacheRoute2): string;
+export declare function updateProjectDataCacheRoute2FromJSON(jsonString: string): SafeParseResult<UpdateProjectDataCacheRoute2, SDKValidationError>;
+/** @internal */
+export declare const UpdateProjectDataCacheRoute1$inboundSchema: z.ZodType<UpdateProjectDataCacheRoute1, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheRoute1$Outbound = {
+    src: string;
+    status: number;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheRoute1$outboundSchema: z.ZodType<UpdateProjectDataCacheRoute1$Outbound, z.ZodTypeDef, UpdateProjectDataCacheRoute1>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheRoute1$ {
+    /** @deprecated use `UpdateProjectDataCacheRoute1$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheRoute1, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheRoute1$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheRoute1$Outbound, z.ZodTypeDef, UpdateProjectDataCacheRoute1>;
+    /** @deprecated use `UpdateProjectDataCacheRoute1$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheRoute1$Outbound;
+}
+export declare function updateProjectDataCacheRoute1ToJSON(updateProjectDataCacheRoute1: UpdateProjectDataCacheRoute1): string;
+export declare function updateProjectDataCacheRoute1FromJSON(jsonString: string): SafeParseResult<UpdateProjectDataCacheRoute1, SDKValidationError>;
+/** @internal */
+export declare const BlockHistoryRoute$inboundSchema: z.ZodType<BlockHistoryRoute, z.ZodTypeDef, unknown>;
+/** @internal */
+export type BlockHistoryRoute$Outbound = UpdateProjectDataCacheRoute1$Outbound | UpdateProjectDataCacheRoute2$Outbound;
+/** @internal */
+export declare const BlockHistoryRoute$outboundSchema: z.ZodType<BlockHistoryRoute$Outbound, z.ZodTypeDef, BlockHistoryRoute>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace BlockHistoryRoute$ {
+    /** @deprecated use `BlockHistoryRoute$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<BlockHistoryRoute, z.ZodTypeDef, unknown>;
+    /** @deprecated use `BlockHistoryRoute$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<BlockHistoryRoute$Outbound, z.ZodTypeDef, BlockHistoryRoute>;
+    /** @deprecated use `BlockHistoryRoute$Outbound` instead. */
+    type Outbound = BlockHistoryRoute$Outbound;
+}
+export declare function blockHistoryRouteToJSON(blockHistoryRoute: BlockHistoryRoute): string;
+export declare function blockHistoryRouteFromJSON(jsonString: string): SafeParseResult<BlockHistoryRoute, SDKValidationError>;
+/** @internal */
+export declare const BlockHistory4$inboundSchema: z.ZodType<BlockHistory4, z.ZodTypeDef, unknown>;
+/** @internal */
+export type BlockHistory4$Outbound = {
+    action: string;
+    route: UpdateProjectDataCacheRoute1$Outbound | UpdateProjectDataCacheRoute2$Outbound;
+    statusCode?: number | undefined;
+    createdAt: number;
+    caseId?: string | undefined;
+    actor?: string | undefined;
+    comment?: string | undefined;
+    isCascading?: boolean | undefined;
+};
+/** @internal */
+export declare const BlockHistory4$outboundSchema: z.ZodType<BlockHistory4$Outbound, z.ZodTypeDef, BlockHistory4>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace BlockHistory4$ {
+    /** @deprecated use `BlockHistory4$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<BlockHistory4, z.ZodTypeDef, unknown>;
+    /** @deprecated use `BlockHistory4$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<BlockHistory4$Outbound, z.ZodTypeDef, BlockHistory4>;
+    /** @deprecated use `BlockHistory4$Outbound` instead. */
+    type Outbound = BlockHistory4$Outbound;
+}
+export declare function blockHistory4ToJSON(blockHistory4: BlockHistory4): string;
+export declare function blockHistory4FromJSON(jsonString: string): SafeParseResult<BlockHistory4, SDKValidationError>;
+/** @internal */
+export declare const UpdateProjectDataCacheBlockHistoryProjectsAction$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheBlockHistoryProjectsAction>;
+/** @internal */
+export declare const UpdateProjectDataCacheBlockHistoryProjectsAction$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheBlockHistoryProjectsAction>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheBlockHistoryProjectsAction$ {
+    /** @deprecated use `UpdateProjectDataCacheBlockHistoryProjectsAction$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly RouteBlocked: "route-blocked";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheBlockHistoryProjectsAction$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly RouteBlocked: "route-blocked";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType>;
+/** @internal */
+export declare const UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType$ {
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Host: "host";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponse200ApplicationJSONType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Host: "host";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheHasProjectsResponse200Value$inboundSchema: z.ZodType<UpdateProjectDataCacheHasProjectsResponse200Value, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheHasProjectsResponse200Value$Outbound = {
+    eq: string;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheHasProjectsResponse200Value$outboundSchema: z.ZodType<UpdateProjectDataCacheHasProjectsResponse200Value$Outbound, z.ZodTypeDef, UpdateProjectDataCacheHasProjectsResponse200Value>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheHasProjectsResponse200Value$ {
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponse200Value$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheHasProjectsResponse200Value, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponse200Value$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheHasProjectsResponse200Value$Outbound, z.ZodTypeDef, UpdateProjectDataCacheHasProjectsResponse200Value>;
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponse200Value$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheHasProjectsResponse200Value$Outbound;
+}
+export declare function updateProjectDataCacheHasProjectsResponse200ValueToJSON(updateProjectDataCacheHasProjectsResponse200Value: UpdateProjectDataCacheHasProjectsResponse200Value): string;
+export declare function updateProjectDataCacheHasProjectsResponse200ValueFromJSON(jsonString: string): SafeParseResult<UpdateProjectDataCacheHasProjectsResponse200Value, SDKValidationError>;
+/** @internal */
+export declare const UpdateProjectDataCacheHasProjects2$inboundSchema: z.ZodType<UpdateProjectDataCacheHasProjects2, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheHasProjects2$Outbound = {
+    type: string;
+    value: UpdateProjectDataCacheHasProjectsResponse200Value$Outbound;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheHasProjects2$outboundSchema: z.ZodType<UpdateProjectDataCacheHasProjects2$Outbound, z.ZodTypeDef, UpdateProjectDataCacheHasProjects2>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheHasProjects2$ {
+    /** @deprecated use `UpdateProjectDataCacheHasProjects2$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheHasProjects2, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheHasProjects2$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheHasProjects2$Outbound, z.ZodTypeDef, UpdateProjectDataCacheHasProjects2>;
+    /** @deprecated use `UpdateProjectDataCacheHasProjects2$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheHasProjects2$Outbound;
+}
+export declare function updateProjectDataCacheHasProjects2ToJSON(updateProjectDataCacheHasProjects2: UpdateProjectDataCacheHasProjects2): string;
+export declare function updateProjectDataCacheHasProjects2FromJSON(jsonString: string): SafeParseResult<UpdateProjectDataCacheHasProjects2, SDKValidationError>;
+/** @internal */
+export declare const UpdateProjectDataCacheHasProjectsResponse200Type$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheHasProjectsResponse200Type>;
+/** @internal */
+export declare const UpdateProjectDataCacheHasProjectsResponse200Type$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheHasProjectsResponse200Type>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheHasProjectsResponse200Type$ {
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponse200Type$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Header: "header";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponse200Type$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Header: "header";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheHasKey$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheHasKey>;
+/** @internal */
+export declare const UpdateProjectDataCacheHasKey$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheHasKey>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheHasKey$ {
+    /** @deprecated use `UpdateProjectDataCacheHasKey$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly XVercelIpCountry: "x-vercel-ip-country";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheHasKey$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly XVercelIpCountry: "x-vercel-ip-country";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheHasProjectsResponseValue$inboundSchema: z.ZodType<UpdateProjectDataCacheHasProjectsResponseValue, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheHasProjectsResponseValue$Outbound = {
+    eq: string;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheHasProjectsResponseValue$outboundSchema: z.ZodType<UpdateProjectDataCacheHasProjectsResponseValue$Outbound, z.ZodTypeDef, UpdateProjectDataCacheHasProjectsResponseValue>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheHasProjectsResponseValue$ {
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponseValue$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheHasProjectsResponseValue, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponseValue$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheHasProjectsResponseValue$Outbound, z.ZodTypeDef, UpdateProjectDataCacheHasProjectsResponseValue>;
+    /** @deprecated use `UpdateProjectDataCacheHasProjectsResponseValue$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheHasProjectsResponseValue$Outbound;
+}
+export declare function updateProjectDataCacheHasProjectsResponseValueToJSON(updateProjectDataCacheHasProjectsResponseValue: UpdateProjectDataCacheHasProjectsResponseValue): string;
+export declare function updateProjectDataCacheHasProjectsResponseValueFromJSON(jsonString: string): SafeParseResult<UpdateProjectDataCacheHasProjectsResponseValue, SDKValidationError>;
+/** @internal */
+export declare const UpdateProjectDataCacheHasProjects1$inboundSchema: z.ZodType<UpdateProjectDataCacheHasProjects1, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheHasProjects1$Outbound = {
+    type: string;
+    key: string;
+    value: UpdateProjectDataCacheHasProjectsResponseValue$Outbound;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheHasProjects1$outboundSchema: z.ZodType<UpdateProjectDataCacheHasProjects1$Outbound, z.ZodTypeDef, UpdateProjectDataCacheHasProjects1>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheHasProjects1$ {
+    /** @deprecated use `UpdateProjectDataCacheHasProjects1$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheHasProjects1, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheHasProjects1$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheHasProjects1$Outbound, z.ZodTypeDef, UpdateProjectDataCacheHasProjects1>;
+    /** @deprecated use `UpdateProjectDataCacheHasProjects1$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheHasProjects1$Outbound;
+}
+export declare function updateProjectDataCacheHasProjects1ToJSON(updateProjectDataCacheHasProjects1: UpdateProjectDataCacheHasProjects1): string;
+export declare function updateProjectDataCacheHasProjects1FromJSON(jsonString: string): SafeParseResult<UpdateProjectDataCacheHasProjects1, SDKValidationError>;
+/** @internal */
+export declare const UpdateProjectDataCacheRouteHas$inboundSchema: z.ZodType<UpdateProjectDataCacheRouteHas, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheRouteHas$Outbound = UpdateProjectDataCacheHasProjects1$Outbound | UpdateProjectDataCacheHasProjects2$Outbound;
+/** @internal */
+export declare const UpdateProjectDataCacheRouteHas$outboundSchema: z.ZodType<UpdateProjectDataCacheRouteHas$Outbound, z.ZodTypeDef, UpdateProjectDataCacheRouteHas>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheRouteHas$ {
+    /** @deprecated use `UpdateProjectDataCacheRouteHas$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheRouteHas, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheRouteHas$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheRouteHas$Outbound, z.ZodTypeDef, UpdateProjectDataCacheRouteHas>;
+    /** @deprecated use `UpdateProjectDataCacheRouteHas$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheRouteHas$Outbound;
+}
+export declare function updateProjectDataCacheRouteHasToJSON(updateProjectDataCacheRouteHas: UpdateProjectDataCacheRouteHas): string;
+export declare function updateProjectDataCacheRouteHasFromJSON(jsonString: string): SafeParseResult<UpdateProjectDataCacheRouteHas, SDKValidationError>;
+/** @internal */
+export declare const RouteAction$inboundSchema: z.ZodNativeEnum<typeof RouteAction>;
+/** @internal */
+export declare const RouteAction$outboundSchema: z.ZodNativeEnum<typeof RouteAction>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace RouteAction$ {
+    /** @deprecated use `RouteAction$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly BlockLegalCwc: "block_legal_cwc";
+    }>;
+    /** @deprecated use `RouteAction$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly BlockLegalCwc: "block_legal_cwc";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheRouteMitigate$inboundSchema: z.ZodType<UpdateProjectDataCacheRouteMitigate, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheRouteMitigate$Outbound = {
+    action: string;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheRouteMitigate$outboundSchema: z.ZodType<UpdateProjectDataCacheRouteMitigate$Outbound, z.ZodTypeDef, UpdateProjectDataCacheRouteMitigate>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheRouteMitigate$ {
+    /** @deprecated use `UpdateProjectDataCacheRouteMitigate$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheRouteMitigate, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheRouteMitigate$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheRouteMitigate$Outbound, z.ZodTypeDef, UpdateProjectDataCacheRouteMitigate>;
+    /** @deprecated use `UpdateProjectDataCacheRouteMitigate$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheRouteMitigate$Outbound;
+}
+export declare function updateProjectDataCacheRouteMitigateToJSON(updateProjectDataCacheRouteMitigate: UpdateProjectDataCacheRouteMitigate): string;
+export declare function updateProjectDataCacheRouteMitigateFromJSON(jsonString: string): SafeParseResult<UpdateProjectDataCacheRouteMitigate, SDKValidationError>;
+/** @internal */
+export declare const Route2$inboundSchema: z.ZodType<Route2, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Route2$Outbound = {
+    has: Array<UpdateProjectDataCacheHasProjects1$Outbound | UpdateProjectDataCacheHasProjects2$Outbound>;
+    mitigate: UpdateProjectDataCacheRouteMitigate$Outbound;
+    src?: string | undefined;
+};
+/** @internal */
+export declare const Route2$outboundSchema: z.ZodType<Route2$Outbound, z.ZodTypeDef, Route2>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Route2$ {
+    /** @deprecated use `Route2$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Route2, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Route2$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Route2$Outbound, z.ZodTypeDef, Route2>;
+    /** @deprecated use `Route2$Outbound` instead. */
+    type Outbound = Route2$Outbound;
+}
+export declare function route2ToJSON(route2: Route2): string;
+export declare function route2FromJSON(jsonString: string): SafeParseResult<Route2, SDKValidationError>;
+/** @internal */
+export declare const Route1$inboundSchema: z.ZodType<Route1, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Route1$Outbound = {
+    src: string;
+    status: number;
+};
+/** @internal */
+export declare const Route1$outboundSchema: z.ZodType<Route1$Outbound, z.ZodTypeDef, Route1>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Route1$ {
+    /** @deprecated use `Route1$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Route1, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Route1$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Route1$Outbound, z.ZodTypeDef, Route1>;
+    /** @deprecated use `Route1$Outbound` instead. */
+    type Outbound = Route1$Outbound;
+}
+export declare function route1ToJSON(route1: Route1): string;
+export declare function route1FromJSON(jsonString: string): SafeParseResult<Route1, SDKValidationError>;
+/** @internal */
+export declare const Route$inboundSchema: z.ZodType<Route, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Route$Outbound = Route1$Outbound | Route2$Outbound;
+/** @internal */
+export declare const Route$outboundSchema: z.ZodType<Route$Outbound, z.ZodTypeDef, Route>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Route$ {
+    /** @deprecated use `Route$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Route, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Route$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Route$Outbound, z.ZodTypeDef, Route>;
+    /** @deprecated use `Route$Outbound` instead. */
+    type Outbound = Route$Outbound;
+}
+export declare function routeToJSON(route: Route): string;
+export declare function routeFromJSON(jsonString: string): SafeParseResult<Route, SDKValidationError>;
+/** @internal */
+export declare const BlockHistory3$inboundSchema: z.ZodType<BlockHistory3, z.ZodTypeDef, unknown>;
+/** @internal */
+export type BlockHistory3$Outbound = {
+    action: string;
+    route: Route1$Outbound | Route2$Outbound;
+    reason: string;
+    createdAt: number;
+    caseId?: string | undefined;
+    actor?: string | undefined;
+    comment?: string | undefined;
+    isCascading?: boolean | undefined;
+};
+/** @internal */
+export declare const BlockHistory3$outboundSchema: z.ZodType<BlockHistory3$Outbound, z.ZodTypeDef, BlockHistory3>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace BlockHistory3$ {
+    /** @deprecated use `BlockHistory3$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<BlockHistory3, z.ZodTypeDef, unknown>;
+    /** @deprecated use `BlockHistory3$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<BlockHistory3$Outbound, z.ZodTypeDef, BlockHistory3>;
+    /** @deprecated use `BlockHistory3$Outbound` instead. */
+    type Outbound = BlockHistory3$Outbound;
+}
+export declare function blockHistory3ToJSON(blockHistory3: BlockHistory3): string;
+export declare function blockHistory3FromJSON(jsonString: string): SafeParseResult<BlockHistory3, SDKValidationError>;
+/** @internal */
+export declare const UpdateProjectDataCacheBlockHistoryAction$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheBlockHistoryAction>;
+/** @internal */
+export declare const UpdateProjectDataCacheBlockHistoryAction$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheBlockHistoryAction>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheBlockHistoryAction$ {
+    /** @deprecated use `UpdateProjectDataCacheBlockHistoryAction$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Unblocked: "unblocked";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheBlockHistoryAction$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Unblocked: "unblocked";
+    }>;
+}
+/** @internal */
+export declare const BlockHistory2$inboundSchema: z.ZodType<BlockHistory2, z.ZodTypeDef, unknown>;
+/** @internal */
+export type BlockHistory2$Outbound = {
+    action: string;
+    createdAt: number;
+    caseId?: string | undefined;
+    actor?: string | undefined;
+    comment?: string | undefined;
+    isCascading?: boolean | undefined;
+};
+/** @internal */
+export declare const BlockHistory2$outboundSchema: z.ZodType<BlockHistory2$Outbound, z.ZodTypeDef, BlockHistory2>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace BlockHistory2$ {
+    /** @deprecated use `BlockHistory2$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<BlockHistory2, z.ZodTypeDef, unknown>;
+    /** @deprecated use `BlockHistory2$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<BlockHistory2$Outbound, z.ZodTypeDef, BlockHistory2>;
+    /** @deprecated use `BlockHistory2$Outbound` instead. */
+    type Outbound = BlockHistory2$Outbound;
+}
+export declare function blockHistory2ToJSON(blockHistory2: BlockHistory2): string;
+export declare function blockHistory2FromJSON(jsonString: string): SafeParseResult<BlockHistory2, SDKValidationError>;
+/** @internal */
+export declare const BlockHistoryAction$inboundSchema: z.ZodNativeEnum<typeof BlockHistoryAction>;
+/** @internal */
+export declare const BlockHistoryAction$outboundSchema: z.ZodNativeEnum<typeof BlockHistoryAction>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace BlockHistoryAction$ {
+    /** @deprecated use `BlockHistoryAction$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Blocked: "blocked";
+    }>;
+    /** @deprecated use `BlockHistoryAction$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Blocked: "blocked";
+    }>;
+}
+/** @internal */
+export declare const BlockHistory1$inboundSchema: z.ZodType<BlockHistory1, z.ZodTypeDef, unknown>;
+/** @internal */
+export type BlockHistory1$Outbound = {
+    action: string;
+    reason: string;
+    statusCode: number;
+    createdAt: number;
+    caseId?: string | undefined;
+    actor?: string | undefined;
+    comment?: string | undefined;
+    isCascading?: boolean | undefined;
+};
+/** @internal */
+export declare const BlockHistory1$outboundSchema: z.ZodType<BlockHistory1$Outbound, z.ZodTypeDef, BlockHistory1>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace BlockHistory1$ {
+    /** @deprecated use `BlockHistory1$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<BlockHistory1, z.ZodTypeDef, unknown>;
+    /** @deprecated use `BlockHistory1$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<BlockHistory1$Outbound, z.ZodTypeDef, BlockHistory1>;
+    /** @deprecated use `BlockHistory1$Outbound` instead. */
+    type Outbound = BlockHistory1$Outbound;
+}
+export declare function blockHistory1ToJSON(blockHistory1: BlockHistory1): string;
+export declare function blockHistory1FromJSON(jsonString: string): SafeParseResult<BlockHistory1, SDKValidationError>;
+/** @internal */
+export declare const UpdateProjectDataCacheBlockHistory$inboundSchema: z.ZodType<UpdateProjectDataCacheBlockHistory, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheBlockHistory$Outbound = BlockHistory1$Outbound | BlockHistory3$Outbound | BlockHistory4$Outbound | BlockHistory2$Outbound;
+/** @internal */
+export declare const UpdateProjectDataCacheBlockHistory$outboundSchema: z.ZodType<UpdateProjectDataCacheBlockHistory$Outbound, z.ZodTypeDef, UpdateProjectDataCacheBlockHistory>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheBlockHistory$ {
+    /** @deprecated use `UpdateProjectDataCacheBlockHistory$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheBlockHistory, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheBlockHistory$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheBlockHistory$Outbound, z.ZodTypeDef, UpdateProjectDataCacheBlockHistory>;
+    /** @deprecated use `UpdateProjectDataCacheBlockHistory$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheBlockHistory$Outbound;
+}
+export declare function updateProjectDataCacheBlockHistoryToJSON(updateProjectDataCacheBlockHistory: UpdateProjectDataCacheBlockHistory): string;
+export declare function updateProjectDataCacheBlockHistoryFromJSON(jsonString: string): SafeParseResult<UpdateProjectDataCacheBlockHistory, SDKValidationError>;
+/** @internal */
+export declare const UpdateProjectDataCacheAbuse$inboundSchema: z.ZodType<UpdateProjectDataCacheAbuse, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheAbuse$Outbound = {
+    scanner?: string | undefined;
+    history: Array<UpdateProjectDataCacheHistory$Outbound>;
+    updatedAt: number;
+    block?: Block$Outbound | undefined;
+    blockHistory?: Array<BlockHistory1$Outbound | BlockHistory3$Outbound | BlockHistory4$Outbound | BlockHistory2$Outbound> | undefined;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheAbuse$outboundSchema: z.ZodType<UpdateProjectDataCacheAbuse$Outbound, z.ZodTypeDef, UpdateProjectDataCacheAbuse>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheAbuse$ {
+    /** @deprecated use `UpdateProjectDataCacheAbuse$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheAbuse, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheAbuse$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheAbuse$Outbound, z.ZodTypeDef, UpdateProjectDataCacheAbuse>;
+    /** @deprecated use `UpdateProjectDataCacheAbuse$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheAbuse$Outbound;
+}
+export declare function updateProjectDataCacheAbuseToJSON(updateProjectDataCacheAbuse: UpdateProjectDataCacheAbuse): string;
+export declare function updateProjectDataCacheAbuseFromJSON(jsonString: string): SafeParseResult<UpdateProjectDataCacheAbuse, SDKValidationError>;
+/** @internal */
+export declare const UpdateProjectDataCacheHasType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheHasType>;
+/** @internal */
+export declare const UpdateProjectDataCacheHasType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheHasType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheHasType$ {
+    /** @deprecated use `UpdateProjectDataCacheHasType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Host: "host";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheHasType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Host: "host";
+    }>;
+}
+/** @internal */
+export declare const HasValue$inboundSchema: z.ZodType<HasValue, z.ZodTypeDef, unknown>;
+/** @internal */
+export type HasValue$Outbound = {
+    eq: string;
+};
+/** @internal */
+export declare const HasValue$outboundSchema: z.ZodType<HasValue$Outbound, z.ZodTypeDef, HasValue>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace HasValue$ {
+    /** @deprecated use `HasValue$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<HasValue, z.ZodTypeDef, unknown>;
+    /** @deprecated use `HasValue$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<HasValue$Outbound, z.ZodTypeDef, HasValue>;
+    /** @deprecated use `HasValue$Outbound` instead. */
+    type Outbound = HasValue$Outbound;
+}
+export declare function hasValueToJSON(hasValue: HasValue): string;
+export declare function hasValueFromJSON(jsonString: string): SafeParseResult<HasValue, SDKValidationError>;
+/** @internal */
+export declare const Has2$inboundSchema: z.ZodType<Has2, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Has2$Outbound = {
+    type: string;
+    value: HasValue$Outbound;
+};
+/** @internal */
+export declare const Has2$outboundSchema: z.ZodType<Has2$Outbound, z.ZodTypeDef, Has2>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Has2$ {
+    /** @deprecated use `Has2$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Has2, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Has2$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Has2$Outbound, z.ZodTypeDef, Has2>;
+    /** @deprecated use `Has2$Outbound` instead. */
+    type Outbound = Has2$Outbound;
+}
+export declare function has2ToJSON(has2: Has2): string;
+export declare function has2FromJSON(jsonString: string): SafeParseResult<Has2, SDKValidationError>;
+/** @internal */
+export declare const HasType$inboundSchema: z.ZodNativeEnum<typeof HasType>;
+/** @internal */
+export declare const HasType$outboundSchema: z.ZodNativeEnum<typeof HasType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace HasType$ {
+    /** @deprecated use `HasType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Header: "header";
+    }>;
+    /** @deprecated use `HasType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Header: "header";
+    }>;
+}
+/** @internal */
+export declare const Key$inboundSchema: z.ZodNativeEnum<typeof Key>;
+/** @internal */
+export declare const Key$outboundSchema: z.ZodNativeEnum<typeof Key>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Key$ {
+    /** @deprecated use `Key$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly XVercelIpCountry: "x-vercel-ip-country";
+    }>;
+    /** @deprecated use `Key$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly XVercelIpCountry: "x-vercel-ip-country";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheHasValue$inboundSchema: z.ZodType<UpdateProjectDataCacheHasValue, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheHasValue$Outbound = {
+    eq: string;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheHasValue$outboundSchema: z.ZodType<UpdateProjectDataCacheHasValue$Outbound, z.ZodTypeDef, UpdateProjectDataCacheHasValue>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheHasValue$ {
+    /** @deprecated use `UpdateProjectDataCacheHasValue$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheHasValue, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheHasValue$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheHasValue$Outbound, z.ZodTypeDef, UpdateProjectDataCacheHasValue>;
+    /** @deprecated use `UpdateProjectDataCacheHasValue$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheHasValue$Outbound;
+}
+export declare function updateProjectDataCacheHasValueToJSON(updateProjectDataCacheHasValue: UpdateProjectDataCacheHasValue): string;
+export declare function updateProjectDataCacheHasValueFromJSON(jsonString: string): SafeParseResult<UpdateProjectDataCacheHasValue, SDKValidationError>;
+/** @internal */
+export declare const Has1$inboundSchema: z.ZodType<Has1, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Has1$Outbound = {
+    type: string;
+    key: string;
+    value: UpdateProjectDataCacheHasValue$Outbound;
+};
+/** @internal */
+export declare const Has1$outboundSchema: z.ZodType<Has1$Outbound, z.ZodTypeDef, Has1>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Has1$ {
+    /** @deprecated use `Has1$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Has1, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Has1$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Has1$Outbound, z.ZodTypeDef, Has1>;
+    /** @deprecated use `Has1$Outbound` instead. */
+    type Outbound = Has1$Outbound;
+}
+export declare function has1ToJSON(has1: Has1): string;
+export declare function has1FromJSON(jsonString: string): SafeParseResult<Has1, SDKValidationError>;
+/** @internal */
+export declare const Has$inboundSchema: z.ZodType<Has, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Has$Outbound = Has1$Outbound | Has2$Outbound;
+/** @internal */
+export declare const Has$outboundSchema: z.ZodType<Has$Outbound, z.ZodTypeDef, Has>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Has$ {
+    /** @deprecated use `Has$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Has, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Has$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Has$Outbound, z.ZodTypeDef, Has>;
+    /** @deprecated use `Has$Outbound` instead. */
+    type Outbound = Has$Outbound;
+}
+export declare function hasToJSON(has: Has): string;
+export declare function hasFromJSON(jsonString: string): SafeParseResult<Has, SDKValidationError>;
+/** @internal */
+export declare const InternalRoutesAction$inboundSchema: z.ZodNativeEnum<typeof InternalRoutesAction>;
+/** @internal */
+export declare const InternalRoutesAction$outboundSchema: z.ZodNativeEnum<typeof InternalRoutesAction>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace InternalRoutesAction$ {
+    /** @deprecated use `InternalRoutesAction$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly BlockLegalCwc: "block_legal_cwc";
+    }>;
+    /** @deprecated use `InternalRoutesAction$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly BlockLegalCwc: "block_legal_cwc";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheInternalRoutesMitigate$inboundSchema: z.ZodType<UpdateProjectDataCacheInternalRoutesMitigate, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheInternalRoutesMitigate$Outbound = {
+    action: string;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheInternalRoutesMitigate$outboundSchema: z.ZodType<UpdateProjectDataCacheInternalRoutesMitigate$Outbound, z.ZodTypeDef, UpdateProjectDataCacheInternalRoutesMitigate>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheInternalRoutesMitigate$ {
+    /** @deprecated use `UpdateProjectDataCacheInternalRoutesMitigate$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheInternalRoutesMitigate, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheInternalRoutesMitigate$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheInternalRoutesMitigate$Outbound, z.ZodTypeDef, UpdateProjectDataCacheInternalRoutesMitigate>;
+    /** @deprecated use `UpdateProjectDataCacheInternalRoutesMitigate$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheInternalRoutesMitigate$Outbound;
+}
+export declare function updateProjectDataCacheInternalRoutesMitigateToJSON(updateProjectDataCacheInternalRoutesMitigate: UpdateProjectDataCacheInternalRoutesMitigate): string;
+export declare function updateProjectDataCacheInternalRoutesMitigateFromJSON(jsonString: string): SafeParseResult<UpdateProjectDataCacheInternalRoutesMitigate, SDKValidationError>;
+/** @internal */
+export declare const InternalRoutes2$inboundSchema: z.ZodType<InternalRoutes2, z.ZodTypeDef, unknown>;
+/** @internal */
+export type InternalRoutes2$Outbound = {
+    has: Array<Has1$Outbound | Has2$Outbound>;
+    mitigate: UpdateProjectDataCacheInternalRoutesMitigate$Outbound;
+    src?: string | undefined;
+};
+/** @internal */
+export declare const InternalRoutes2$outboundSchema: z.ZodType<InternalRoutes2$Outbound, z.ZodTypeDef, InternalRoutes2>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace InternalRoutes2$ {
+    /** @deprecated use `InternalRoutes2$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<InternalRoutes2, z.ZodTypeDef, unknown>;
+    /** @deprecated use `InternalRoutes2$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<InternalRoutes2$Outbound, z.ZodTypeDef, InternalRoutes2>;
+    /** @deprecated use `InternalRoutes2$Outbound` instead. */
+    type Outbound = InternalRoutes2$Outbound;
+}
+export declare function internalRoutes2ToJSON(internalRoutes2: InternalRoutes2): string;
+export declare function internalRoutes2FromJSON(jsonString: string): SafeParseResult<InternalRoutes2, SDKValidationError>;
+/** @internal */
+export declare const InternalRoutes1$inboundSchema: z.ZodType<InternalRoutes1, z.ZodTypeDef, unknown>;
+/** @internal */
+export type InternalRoutes1$Outbound = {
+    src: string;
+    status: number;
+};
+/** @internal */
+export declare const InternalRoutes1$outboundSchema: z.ZodType<InternalRoutes1$Outbound, z.ZodTypeDef, InternalRoutes1>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace InternalRoutes1$ {
+    /** @deprecated use `InternalRoutes1$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<InternalRoutes1, z.ZodTypeDef, unknown>;
+    /** @deprecated use `InternalRoutes1$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<InternalRoutes1$Outbound, z.ZodTypeDef, InternalRoutes1>;
+    /** @deprecated use `InternalRoutes1$Outbound` instead. */
+    type Outbound = InternalRoutes1$Outbound;
+}
+export declare function internalRoutes1ToJSON(internalRoutes1: InternalRoutes1): string;
+export declare function internalRoutes1FromJSON(jsonString: string): SafeParseResult<InternalRoutes1, SDKValidationError>;
+/** @internal */
+export declare const InternalRoutes$inboundSchema: z.ZodType<InternalRoutes, z.ZodTypeDef, unknown>;
+/** @internal */
+export type InternalRoutes$Outbound = InternalRoutes1$Outbound | InternalRoutes2$Outbound;
+/** @internal */
+export declare const InternalRoutes$outboundSchema: z.ZodType<InternalRoutes$Outbound, z.ZodTypeDef, InternalRoutes>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace InternalRoutes$ {
+    /** @deprecated use `InternalRoutes$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<InternalRoutes, z.ZodTypeDef, unknown>;
+    /** @deprecated use `InternalRoutes$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<InternalRoutes$Outbound, z.ZodTypeDef, InternalRoutes>;
+    /** @deprecated use `InternalRoutes$Outbound` instead. */
+    type Outbound = InternalRoutes$Outbound;
+}
+export declare function internalRoutesToJSON(internalRoutes: InternalRoutes): string;
+export declare function internalRoutesFromJSON(jsonString: string): SafeParseResult<InternalRoutes, SDKValidationError>;
+/** @internal */
 export declare const UpdateProjectDataCacheResponseBody$inboundSchema: z.ZodType<UpdateProjectDataCacheResponseBody, z.ZodTypeDef, unknown>;
 /** @internal */
 export type UpdateProjectDataCacheResponseBody$Outbound = {
@@ -5481,7 +6824,7 @@ export type UpdateProjectDataCacheResponseBody$Outbound = {
     id: string;
     ipBuckets?: Array<UpdateProjectDataCacheIpBuckets$Outbound> | undefined;
     latestDeployments?: Array<LatestDeployments$Outbound> | undefined;
-    link?: Link3$Outbound | Link4$Outbound | Link5$Outbound | Link1$Outbound | Link2$Outbound | undefined;
+    link?: Link4$Outbound | Link5$Outbound | Link3$Outbound | Link1$Outbound | Link2$Outbound | undefined;
     microfrontends?: UpdateProjectDataCacheMicrofrontends1$Outbound | UpdateProjectDataCacheMicrofrontends2$Outbound | undefined;
     name: string;
     nodeVersion: string;
@@ -5531,6 +6874,8 @@ export type UpdateProjectDataCacheResponseBody$Outbound = {
     tier?: string | undefined;
     features?: Features$Outbound | undefined;
     v0?: boolean | undefined;
+    abuse?: UpdateProjectDataCacheAbuse$Outbound | undefined;
+    internalRoutes?: Array<InternalRoutes1$Outbound | InternalRoutes2$Outbound> | undefined;
 };
 /** @internal */
 export declare const UpdateProjectDataCacheResponseBody$outboundSchema: z.ZodType<UpdateProjectDataCacheResponseBody$Outbound, z.ZodTypeDef, UpdateProjectDataCacheResponseBody>;